精华内容
下载资源
问答
  • Java进阶(四十五)java 字节流与字符流的区别

    万次阅读 多人点赞 2016-10-08 15:25:16
    java 字节流与字符流的区别(转载)  字节流与和字符流的使用非常相似,两者除了操作代码上的不同之外,是否还有其他的不同呢?   实际上字节流在操作时本身不会用到缓冲区(内存),是文件本身直接操作的,而...

    字节流与和字符流的使用非常相似,两者除了操作代码上的不同之外,是否还有其他的不同呢?

    实际上字节流在操作时本身不会用到缓冲区(内存),是文件本身直接操作的,而字符流在操作时使用了缓冲区,通过缓冲区再操作文件,如下图所示。
    这里写图片描述
    下面以两个写文件的操作为主进行比较,但是在操作时字节流和字符流的操作完成之后都不关闭输出流。
    范例:使用字节流不关闭执行

    import java.io.File;    
    import java.io.FileOutputStream;    
    import java.io.OutputStream;    
    public class OutputStreamDemo05 {    
    public static void main(String[] args) throws Exception {   // 异常抛出不处理    
    // 第1步:使用File类找到一个文件    
         File f = new File("d:" + File.separator + "test.txt"); // 声明File对象    
    // 第2步:通过子类实例化父类对象    
         OutputStream out = null;            
    // 准备好一个输出的对象    
         out = new FileOutputStream(f);      
    // 通过对象多态性进行实例化    
    // 第3步:准备一个字符串   
         String str = "Hello World!!!";      
     		 // 字符串转byte数组
         byte b[] = str.getBytes();          
    // 将内容输出,进行写操作 
         out.write(b);    
    // 第4步:关闭输出流(此时没有关闭)    
        // out.close();                   
            }    
        }   
    
    
    

      程序运行结果:
    这里写图片描述
      此时没有关闭字节流操作,但是文件中也依然存在了输出的内容,证明字节流是直接操作文件本身的。而下面继续使用字符流完成,再观察效果。
      范例:使用字符流不关闭执行

    import java.io.File;    
    import java.io.FileWriter;    
    import java.io.Writer;    
    public class WriterDemo03 {    
        public static void main(String[] args) throws Exception { // 异常抛出,不处理    
            // 第1步:使用File类找到一个文件    
            File f = new File("d:" + File.separator + "test.txt");// 声明File 对象    
            // 第2步:准备好一个输出的对象 通过子类实例化父类对象    
            Writer out = null;                 
    // 通过对象多态性进行实例化      
            out = new FileWriter(f);            
            // 第3步:准备一个字符串   
            String str = "Hello World!!!";      
    // 进行写操作   
            out.write(str);                    
    // 将内容输出    
            // 第4步:关闭输出流(此时没有关闭)
            // out.close();              
        }    
    }   
    

      程序运行结果:
    这里写图片描述
      程序运行后会发现文件中没有任何内容,这是因为字符流操作时使用了缓冲区,而在关闭字符流时会强制性地将缓冲区中的内容进行输出,但是如果程序没有关闭,则缓冲区中的内容是无法输出的,所以得出结论:字符流使用了缓冲区,而字节流没有使用缓冲区。
      提问:什么叫缓冲区?
      在很多地方都碰到缓冲区这个名词,那么到底什么是缓冲区?又有什么作用呢?
      回答:缓冲区可以简单地理解为一段特殊的内存区域。
      某些情况下,如果一个程序频繁地操作一个资源(如文件或数据库),则性能会很低,此时为了提升性能,就可以将一部分数据暂时读入到内存的一块区域之中,以后直接从此区域中读取数据即可,因为读取内存速度会比较快,这样可以提升程序的性能。
      在字符流的操作中,所有的字符都是在内存中形成的,在输出前会将所有的内容暂时保存在内存之中,所以使用了缓冲区暂存数据。
      如果想在不关闭时也可以将字符流的内容全部输出,则可以使用Writer类中的flush()方法完成。
      范例:强制性清空缓冲区

    import java.io.File;    
    import java.io.FileWriter;    
    import java.io.Writer;    
    public class WriterDemo04 {    
        public static void main(String[] args) throws Exception { // 异常抛出不处理    
            // 第1步:使用File类找到一个文件    
            File f = new File("d:" + File.separator + "test.txt");// 声明File    
    对象    
            // 第2步:准备好一个输出的对象  通过子类实例化父类对象    
            Writer out = null;                   
    // 通过对象多态性进行实例化
            out = new FileWriter(f); 
            // 第3步:准备一个字符串    
            String str = "Hello World!!!";      
    // 进行写操作
            out.write(str);                    
    // 将内容输出    
            out.flush();                       
    // 强制性清空缓冲区中的内容    
            // 第4步:关闭输出流(此时没有关闭)    
            // out.close();                  
        }    
    }   
    

      程序运行结果:
    这里写图片描述
      此时,文件中已经存在了内容,更进一步证明内容是保存在缓冲区的。这一点在读者日后的开发中要特别引起注意。
      提问:使用字节流好还是字符流好?
      学习完字节流和字符流的基本操作后,已经大概地明白了操作流程的各个区别,那么在开发中是使用字节流好还是字符流好呢?
      在回答之前,先为读者讲解这样的一个概念,所有的文件在硬盘或在传输时都是以字节的方式进行的,包括图片等都是按字节的方式存储的,而字符是只有在内存中才会形成,所以在开发中,字节流使用较为广泛。
      字节流与字符流主要的区别是他们的的处理方式
    流分类:

    • 1.Java的字节流

      InputStream是所有字节输入流的祖先,而OutputStream是所有字节输出流的祖先。

    • 2.Java的字符流

    Reader是所有读取字符串输入流的祖先,而writer是所有输出字符串的祖先InputStreamOutputStream,Reader,writer都是抽象类。所以不能直接new。字节流是最基本的,所有的InputStreamOutputStream的子类都是,主要用在处理二进制数据,它是按字节来处理的。但实际中很多的数据是文本,又提出了字符流的概念,它是按虚拟机的encode来处理,也就是要进行字符集的转化。这两个之间通过 InputStreamReader,OutputStreamWriter来关联,实际上是通过byte[]String来关联。

    在实际开发中出现的汉字问题实际上都是在字符流和字节流之间转化不统一而造成的。在从字节流转化为字符流时,实际上就是byte[]转化为String时,public String(byte bytes[], String charsetName)
    有一个关键的参数字符集编码,通常我们都省略了,那系统就用操作系统的lang。而在字符流转化为字节流时,实际上是String转化为byte[]时,byte[] String.getBytes(String charsetName)也是一样的道理。至于java.io中还出现了许多其他的流,按主要是为了提高性能和使用方便,如BufferedInputStream,PipedInputStream等。

    Java中,它的内核使用 Unicode,也就是说它记住了每个字符的Unicode 内部编码。与ANSI码不兼容。字节。按照UNICODE标准所有字符都占2个字节。因为在Java当中字符是采用Unicode编码标准的,所以“学Java”这个字符串在Java语言中占10个字节。

    展开全文
  • java字节流

    2015-05-05 19:48:53
    /* 字节流 InputStream OutputStream 字节流缓冲区 ...System.in:对应的标准输入设备,键盘InputStreamReader:字符流转换为字节流字节流及其缓冲没有readLine方法,先变为字符流缓冲区 */package pack;i
    /*
    字节流
    InputStream
    OutputStream 
    
    字节流缓冲区
    BufferedInputStream
    BufferedOutputStream
    
    System.out:对应的是标准输出设备,控制台
    System.in:对应的标准输入设备,键盘
    
    InputStreamReader:字符流转换为字节流,字节流及其缓冲没有readLine方法,先变为字符流缓冲区
    */
    
    package pack;
    
    import java.io.BufferedInputStream;
    import java.io.BufferedOutputStream;
    import java.io.BufferedReader;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    
    public class Main {
    
        public static void sys(Object obj) {
            System.out.println(obj);
        }
    
        public static void main(String[] args) throws IOException {
            //method1();
            //method2();
            //method3();
            //method4();
            method5();
        }
    
        public static void method1() throws IOException {
            FileOutputStream fos = new FileOutputStream("E:\\1.txt");
            fos.write("abc".getBytes());//write方法里没有字符串参数,转换为字节数组
            //字节流不需要刷新
            fos.close();
        }
    
        public static void method2() throws IOException {
            FileInputStream fis = new FileInputStream("E:\\1.txt");
            /*int ch = 0;
            while((ch=fis.read())!=-1) //一次读一个
                sys((char)ch);     
            fis.close();*/
    
    
            byte[] buf = new byte[fis.available()];//fis.available是个数
            int len = 0;
            while((len=fis.read(buf))!=-1)
                sys(new String(buf,0,len));
            fis.close();    
        }
    
        /*拷贝图片,字节流*/
        public static void method3() throws IOException {
            FileOutputStream fos = new FileOutputStream("E:\\2.jpg");
            FileInputStream fis = new FileInputStream("E:\\1.jpg");
            int ch = 0;
            while((ch=fis.read())!=-1)
                fos.write(ch);
            fos.close();
            fis.close();
        }
    
        /*拷贝mp3,通过缓冲区*/
        public static void method4() throws IOException {
            BufferedOutputStream bufos=new BufferedOutputStream(new FileOutputStream("E:\\2.mp3"));
            BufferedInputStream bufis=new BufferedInputStream(new FileInputStream("E:\\1.mp3"));
            int ch = 0;
            while((ch=bufis.read())!=-1)
                bufos.write(ch);
            bufis.close();
            bufos.close();
        }
    
        public static void method5() throws IOException {
            //字节流及其缓冲没有readLine方法,先变为字符流缓冲区
            InputStream in = System.in; //获取键盘输入对象
            InputStreamReader isr = new InputStreamReader(in);//字节流转换为字符流
            BufferedReader bufr = new BufferedReader(isr); //字符流缓冲区
            String line = null;
            while((line=bufr.readLine())!=null) {
                if(line.equals("over"))
                    break;
                sys(line);
            }
    
            bufr.close();
        }
    }
    
    展开全文
  • Java 字节流

    千次阅读 2012-05-14 15:52:02
    字节流 抽象基类InputStream、OutputStream 字节流可以操作任何数据 字符流使用的是字符数组;字节流使用的是字节数组 实例9,FileInputStream和FileOutputStream的使用。 FileOutputStream fos = ...

    字节流

     

     

    抽象基类InputStream、OutputStream

     

     

    字节流可以操作任何数据

    字符流使用的是字符数组;字节流使用的是字节数组

     

    实例9,FileInputStream和FileOutputStream的使用。

    FileOutputStream fos = newFileOutputStream("a.txt");

    fos.write("abcde");//直接将数据写入到了目的地。

    fos.close();//只关闭资源。

     

    FileInputStream fis = new FileInputStream("a.txt");

    //fis.available();//获取关联的文件的字节数。

     

    //如果文件体积不是很大,可以这样操作。

    byte[] buf = new byte[fis.available()];//创建一个刚刚好的缓冲区。但是这有一个弊端,就是文件过大,大小超出jvm的内容空间时,会内存溢出。

    fis.read(buf);

     

    System.out.println(new String(buf));

     

    实例9,编写程序copy一个图片。

    BufferedInputStream bufis = newBufferedInputStream(new FileInputStream("1.jpg"));

    BufferedOutputStream bufos = newBufferedOutputStream(new FileOutptStream("2.jpg"));

    int by = 0;

    while((by=bufis.read())!=-1){

           bufos.write(by);

    }

    bufos.close();

    bufis.close();

     

     

    自动更新实例

     

    package com.hbsi;

    import java.io.*;

    importjava.text.SimpleDateFormat;

    import java.util.Date;

    publicclass FileUpdate {

           publicstaticvoid main(String[]args)throws IOException{

                  Stringfname="source.txt";

                  Stringdestdir="backup";

                  update(fname,destdir);

     

           }

           publicstaticvoid update(Stringfname,String destdir)throws IOException{

                  Filef1=new File(fname);

                  Filedest=new File(destdir);

                 

                  if (f1.exists()){

                         if(!dest.exists()){

                                dest.mkdir();

                         }

                         Filef2=new File(dest,fname);

                         long d1=f1.lastModified();

                         longd2=f2.lastModified();

                         if((!f2.exists()) ||(f2.exists() && (d1>d2))){

                                copy(f1,f2);

                         }

                         showFileInfo(f1);

                         showFileInfo(f2);

                  }else{

                         System.out.println(f1.getName()+"文件不存在!");

                  }

           }

           publicstaticvoid copy(File f1,Filef2)throws IOException{

                  FileInputStreamfis=new FileInputStream(f1);

                  FileOutputStreamfos=new FileOutputStream(f2);

                 

                  byte[] buf=newbyte[1024];

                  int len=0;

                  while((len=fis.read(buf))!= -1){

                         fos.write(buf,0, len);

                  }

                  System.out.println("复制"+f2.getName()+"成功");

                 

                  fis.close();

                  fos.close();

           }

           publicstaticvoid showFileInfo(Filef){

                  SimpleDateFormatsdf;

                  sdf=new SimpleDateFormat("yyyy年MM月dd日 hh时mm分");

                 

                  if(f.isFile()){

                         Stringfilepath=f.getAbsolutePath();

                         long l=f.lastModified();

                         Dated=new Date(l);

                         String dateformat=sdf.format(d);

                         System.out.println("文件:"+filepath+"\t"+f.length()+"\t"+dateformat);

                  }else{

                         System.out.println("目录:"+f.getAbsolutePath());

                         File[] files=f.listFiles();

                         for(int i=0;i<files.length;i++){

                                showFileInfo(files[i]);

                         }

                  }

           }

     

    }

     

    展开全文
  • java 字节流与字符流的区别

    万次阅读 多人点赞 2018-08-12 15:18:33
    java 字节流与字符流的区别(转载) 转自:https://blog.csdn.net/sunhuaqiang1/article/details/52756999   字节流与和字符流的使用非常相似,两者除了操作代码上的不同之外,是否还有其他的不同呢?    实际...

    java 字节流与字符流的区别(转载)

    转自:https://blog.csdn.net/sunhuaqiang1/article/details/52756999

      字节流与和字符流的使用非常相似,两者除了操作代码上的不同之外,是否还有其他的不同呢? 
      实际上字节流在操作时本身不会用到缓冲区(内存),是文件本身直接操作的,而字符流在操作时使用了缓冲区,通过缓冲区再操作文件,如下图所示。 

    这里写图片描述

    下面以两个写文件的操作为主进行比较,但是在操作时字节流和字符流的操作完成之后都不关闭输出流。 

    范例:使用字节流不关闭执行

    import java.io.File;    
    import java.io.FileOutputStream;    
    import java.io.OutputStream;    
    public class OutputStreamDemo05 {    
    public static void main(String[] args) throws Exception {   // 异常抛出不处理    
    // 第1步:使用File类找到一个文件    
         File f = new File("d:" + File.separator + "test.txt"); // 声明File对象    
    // 第2步:通过子类实例化父类对象    
         OutputStream out = null;            
    // 准备好一个输出的对象    
         out = new FileOutputStream(f);      
    // 通过对象多态性进行实例化    
    // 第3步:准备一个字符串   
         String str = "Hello World!!!";      
             // 字符串转byte数组
         byte b[] = str.getBytes();          
    // 将内容输出,进行写操作 
         out.write(b);    
    // 第4步:关闭输出流(此时没有关闭)    
        // out.close();                   
            }    
    } 

      程序运行结果: 

    这里写图片描述

      此时没有关闭字节流操作,但是文件中也依然存在了输出的内容,证明字节流是直接操作文件本身的。而下面继续使用字符流完成,再观察效果。 
    范例:使用字符流不关闭执行

    import java.io.File;    
    import java.io.FileWriter;    
    import java.io.Writer;    
    public class WriterDemo03 {    
        public static void main(String[] args) throws Exception { // 异常抛出,不处理    
            // 第1步:使用File类找到一个文件    
            File f = new File("d:" + File.separator + "test.txt");// 声明File 对象    
            // 第2步:准备好一个输出的对象 通过子类实例化父类对象    
            Writer out = null;                 
    // 通过对象多态性进行实例化      
            out = new FileWriter(f);            
            // 第3步:准备一个字符串   
            String str = "Hello World!!!";      
    // 进行写操作   
            out.write(str);                    
    // 将内容输出    
            // 第4步:关闭输出流(此时没有关闭)
            // out.close();              
        }    
    }   

    程序运行结果: 

    这里写图片描述

     程序运行后会发现文件中没有任何内容,这是因为字符流操作时使用了缓冲区,而在关闭字符流时会强制性地将缓冲区中的内容进行输出,但是如果程序没有关闭,则缓冲区中的内容是无法输出的,所以得出结论:字符流使用了缓冲区,而字节流没有使用缓冲区。 
      提问:什么叫缓冲区? 
      在很多地方都碰到缓冲区这个名词,那么到底什么是缓冲区?又有什么作用呢? 
      回答:缓冲区可以简单地理解为一段特殊的内存区域。 
      某些情况下,如果一个程序频繁地操作一个资源(如文件或数据库),则性能会很低,此时为了提升性能,就可以将一部分数据暂时读入到内存的一块区域之中,以后直接从此区域中读取数据即可,因为读取内存速度会比较快,这样可以提升程序的性能。 
      在字符流的操作中,所有的字符都是在内存中形成的,在输出前会将所有的内容暂时保存在内存之中,所以使用了缓冲区暂存数据。 
      如果想在不关闭时也可以将字符流的内容全部输出,则可以使用Writer类中的flush()方法完成。 
      范例:强制性清空缓冲区

    import java.io.File;    
    import java.io.FileWriter;    
    import java.io.Writer;    
    public class WriterDemo04 {    
        public static void main(String[] args) throws Exception { // 异常抛出不处理    
            // 第1步:使用File类找到一个文件    
            File f = new File("d:" + File.separator + "test.txt");// 声明File    
    对象    
            // 第2步:准备好一个输出的对象  通过子类实例化父类对象    
            Writer out = null;                   
    // 通过对象多态性进行实例化
            out = new FileWriter(f); 
            // 第3步:准备一个字符串    
            String str = "Hello World!!!";      
    // 进行写操作
            out.write(str);                    
    // 将内容输出    
            out.flush();                       
    // 强制性清空缓冲区中的内容    
            // 第4步:关闭输出流(此时没有关闭)    
            // out.close();                  
        }    
    }   

     程序运行结果: 

    这里写图片描述

    此时,文件中已经存在了内容,更进一步证明内容是保存在缓冲区的。这一点在读者日后的开发中要特别引起注意。 
      提问:使用字节流好还是字符流好? 
      学习完字节流和字符流的基本操作后,已经大概地明白了操作流程的各个区别,那么在开发中是使用字节流好还是字符流好呢? 
      在回答之前,先为读者讲解这样的一个概念,所有的文件在硬盘或在传输时都是以字节的方式进行的,包括图片等都是按字节的方式存储的,而字符是只有在内存中才会形成,所以在开发中,字节流使用较为广泛。 
      字节流与字符流主要的区别是他们的的处理方式 
    流分类:

    • 1.Java的字节流

      InputStream是所有字节输入流的祖先,而OutputStream是所有字节输出流的祖先。

    • 2.Java的字符流

      Reader是所有读取字符串输入流的祖先,而writer是所有输出字符串的祖先。 
        InputStream,OutputStream,Reader,writer都是抽象类。所以不能直接new。 
        字节流是最基本的,所有的InputStream和OutputStream的子类都是,主要用在处理二进制数据,它是按字节来处理的。但实际中很多的数据是文本,又提出了字符流的概念,它是按虚拟机的encode来处理,也就是要进行字符集的转化。这两个之间通过 InputStreamReader,OutputStreamWriter来关联,实际上是通过byte[]和String来关联。 
        在实际开发中出现的汉字问题实际上都是在字符流和字节流之间转化不统一而造成的。在从字节流转化为字符流时,实际上就是byte[]转化为String时,public String(byte bytes[], String charsetName) 
      有一个关键的参数字符集编码,通常我们都省略了,那系统就用操作系统的lang。而在字符流转化为字节流时,实际上是String转化为byte[]时,byte[] String.getBytes(String charsetName)也是一样的道理。至于java.io中还出现了许多其他的流,按主要是为了提高性能和使用方便,如BufferedInputStream,PipedInputStream等。

    注:

      在Java中,它的内核使用 Unicode,也就是说它记住了每个字符的Unicode 内部编码。与ANSI码不兼容。 
      按照ANSI编码标准,标点符号、数字、大小写字母都占一个字节,汉字占2个字节。按照UNICODE标准所有字符都占2个字节。 
      因为在Java当中字符是采用Unicode编码标准的,所以“学Java”这个字符串在Java语言中占10个字节。 

    展开全文
  • Java 字节流,字符流,输入流和输出流概念介绍IO流的分类字节流和字符流 IO流的分类 按照数据类型:字符流和字节流;按照数据流向:输入流和输出流 字节流和字符流 字符流的由来:因为数据编码的不同,而有了对...
  • Java 字节流与字符流的区别

    千次阅读 2016-04-20 20:16:01
    Java 字节流与字符流的区别
  • Java字节流和字符流的区别 首先我们先大概总结一下前面学习的内容,可分为以下几点: 以 Stream 结尾都是字节流,Reader 和 Writer 结尾都是字符流。 InputStream 是所有字节输入流的父类,OutputStream 是所有字节...
  • java 字节流输入输出中文

    千次阅读 2018-01-03 13:48:59
    关于java字节流从文件输入\输出(datainputstream\inputstream等)中文乱码问题
  • Java字节流读取汉字乱码

    千次阅读 2019-04-03 16:20:09
    关于Java字节流读取汉字乱码探究 问题概述 当我们尝试使用字节流对汉字进行写入读取操作时,可能出现乱码。其根本原因在于编码标准不同。汉字采用gbk,而idea使用UTF-8。在这样的前提下,开始讨论本文题。 使用...
  • java字节流做文件拷贝

    2018-04-12 04:44:21
    ------------------------------java字节流做文件拷贝-------------------------------- 字节流拷贝不但能能对文件进行拷贝,还能对字节文件进行拷贝,比如:图片,MP3,MP4。 范例: 使用字节流来拷贝文件 ...
  • Java字节流与字符流

    2012-03-12 23:03:39
    ************Java字节流与字符流 * 1、测试环境:Fedora("in.txt"文件的编码为utf-8,“中”占3个字节) * 2、Linux下如何查看文件编码格式:vim下[:set fileencoding] * 3、以单字节十六进制形式查看文件:od ...
  • Java字节流实现文件夹的拷贝

    千次阅读 2016-12-15 09:08:47
    import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.io....java字节流实现文件夹的拷贝拷
  • java字节流和字符流

    2009-07-27 23:44:00
    java字节流和字符流Java流操作 对于我们常用的GBK中,英文是占用1个字节,中文是2个对于UTF-8,英文是1个,中文是3个对于Unicode,英文中文都是2个 Java的流操作分为字节流和字符流两种。1、 字节流所有的读操作...
  • 导读 本文介绍如何将内存数组流的数据写入文件流中。即将内存数组流中的数据通过文件流写到磁盘上,也叫flush,或持久化。毕竟内存是短暂的,磁盘才是永恒。 流就像管道,数据就像管道里的...在 java 字节流入门(...
  • Java 字节流 字符流 转换流

    万次阅读 2015-05-10 13:55:16
    我们知道Java中的流分为字符流和字节流,其中字符流主要针对字符文本进行处理,而字节流处理范围更为广泛,毕竟图片、电影等只要是文件都是以二进制的形式存在的,而不是字符。 字符流: FileReader FileWriter。 ...
  • 字节流写数据 字节流抽象基类 InputStream : 这个抽象类是表示字节输入流的所有类的超类 OutputStream : 这个抽象类是表示字节输出流的所有类的超类 子类名特点 : 子类名称都是以其父类名作为子类名的后缀 ...
  • Java字节流与字符流及文件操作

    千次阅读 2020-07-21 13:29:34
    目录Java.io知识点梳理File类字节流OutputStream字节流InputStream字符流Writer字符流Reader字节流与字符流的转换(了解)字节流与字符流的区别?两者如何使用? Java.io知识点梳理 如果要进行所有的文件以及文件...
  • Java字节流与字符流读写文件

    千次阅读 2018-12-11 19:04:04
    Java中文件读写有多种方式,但有一种读写方式可以处理任何场景的文件读写,就是字节流的读写。 package com.main.stream; import java.io.File; import java.io.FileInputStream; import java.io....
  • Java 字节流读写文件

    千次阅读 2019-05-07 09:49:31
    Java字节流读写文件 针对文件的读写,JDK专门提供了两个类,分别是 FileInputStream 和 FileOutputStream ,它们都是InputStream 的子类。 FileInputStream 是操作文件的字节输入流,专门用于读取文件中的数据。 ...
  • InputStream此抽象类是表示字节输入的所有类的超类。需要定义 InputStream 的子类的应用程序必须始终提供返回下一个输入字节的方法。int available()返回此输入方法的下一个调用方可以不受阻塞地从此输入读取...
  • 实际上字节流在操作时本身不会用到缓冲区(内存),是文件本身直接操作的,而字符流在操作时使用了缓冲区,通过缓冲区再操作文件。 下面以两个写文件的操作为主进行比较,但是在操作时字节流和字符
  • 1. 什么是流 Java中的流是对字节序列的抽象,我们可以想象有一个水管,只不过现在流动在水管中的... 字节流 Java中的字节流处理的最基本单位为单个字节,它通常用来处理二进制数据。Java中最基本的两个字节流类是I...
  • JAVA字节流和字符流的区别

    千次阅读 2020-07-02 15:02:45
    之前在复习IO的时候,为了方便记忆,提到了以Stream结尾的为字节流,以Writer或者Reader结尾的为字符流。 除了在使用上的不一样,那究竟两者有什么区别呢。直接给出结论:字节流在操作时本身不会用到缓冲区(内存)...
  • Java 字节流读数据

    2020-02-29 12:36:21
    字节流读数据(一次读一个字节数据) 把文件IO.txt中的内容读取出来在控制台输出 FileInputStream:从文件系统中的文件获取输入字节 FilelnputStream(String name): 通过打开与实际文件的连接来创建一个 ...
  • JAVA字节流读写中文

    2019-02-08 21:24:16
    1.字节流读取中文的问题 字节流在读中文的时候有可能会读到半个中文,造成乱码  2.字节流写出中文的问题 字节流直接操作的字节,所以写出中文必须将字符串转换成字节数组,写出回车换行 write("\r\n"....
  • java字节流字符流

    2013-08-10 14:12:53
    字符流处理的单元为2个字节的Unicode字符,分别操作字符、字符数组或字符串,而字节流处理单元为1个字节, 操作字节和字节数组。所以字符流是由Java虚拟机将字节转化为2个字节的Unicode字符为单位的字符而成的,所以...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 37,803
精华内容 15,121
关键字:

java字节流

java 订阅