部分IO流

部分IO流图解

---

几种常用IO流用法

• 字节流读写文件

  • OutputStream和InputStream都是抽象类，分别是表示字节输出流和字节输入流的所有类的超类，即父类（爷爷类，祖父类……）

    ---

  • 文件输出流 —>FileOutputStream
    

    //FileOutputStream输出文件3种成员方法
    
    //1：void write(byte[] b, int off, int len)
    FileOutputStream fos=new FileOutputStream("1.txt");
    byte[] bArr={65,66,67,68};//A,B,C,D
    fos.write(bArr,1,2);
    fos.close();
    
    //2. void write(byte[] b)
    FileOutputStream fos=new FileOutputStream("2.txt");
    byte[] bArr="abc".getBytes();//{97,98,99}
    fos.write(bArr);//abc
    fos.close();
    
    //3.void write(int b)
    FileOutputStream fos=new FileOutputStream("3.txt");
    fos.write(100);//把100这个字节写入到3.txt
    fos.close();
    
    //文件续写和换行问题
    
    //1.续写，调用第二或第五个构造方法
    FileOutputStream fos=new FileOutputStream("3.txt"，true);
    //2.换行
    fos.write("\r\n".getBytes());//换行代码
    fos.close();

    ---

  • 文件输入流—>FileInputStream
    

    //FileInputStream输入文件2种成员方法
    FileInputStream fis=new FileInputStream("1.txt");
    //1. int read()
        //a.利用输入流中的方法读取文件中的字节，一个一个读取
        int b=fis.read();
        System.out.println(b);//a    
        int b2=fis.read();
        System.out.println(b2);//b
        //b.循环可以读出文件中所有的字节
        int b;
        while((b=fis.read())!=-1){
            System.out.println((char)b);
        }
    fis.close();
    
    //2. int read(byte[] b)
    FileInputStream fis=new FileInputStream("5.txt");
    byte[] bArr=new byte[2];
    int len;
    while((len=fis.read(bArr))!=-1){
        System.out.println(new String(bArr,0,len));
        System.out.println(len);
    }
    fis.close();

    ---

  • 复制文件
    复制文件可以采用频繁逐一传递或者打包一起传递两种方式，第一种效率太低，所以只介绍第二种方式
    

    FileInputStream fis=new FileInputStream("abc.png");
    FileOutputStream fos=new FileOutputStream("copy.png");
    
    //利用字节数组拷贝,提高效率
    byte[] b=new byte[1024];//一般开辟1024整数倍
    int len;
    while((len=fis.read(b))!=-1){
        fos.write(b,0,len);//读到几个写几个
    }
    fis.close();
    fos.close();

  ---

• 字符流读写文件

  • Writer和Reader属于字符输出输入流的所有类的超类，同样是抽象类。字符流的使用主要是为了简化当文件中包含中文时的读写操作，换而言之字节流是可以对有中文文件的进行读写操作，但是其效率不如字符流。

    ---

  • 字符输出流—>FileWriter
    

    //FileWriter输出文件4种成员方法(只介绍3种用)
    
    //1.void write(char[] c, in t off,in t len)
    FileWriter fw=new FileWriter("b.txt");
    char[] chArr={'你','a','b'};
    fw.write(chArr, 1, 2);
    fw.close();
    
    //2.void write(char[] c) 
    FileWriter fw=new FileWriter("b.txt");
    char[] chArr={'你','a','b'};
    fw.write(chArr);
    fw.close();
    
    //3.void write(String str)
    FileWriter fw=new FileWriter("b.txt");
    fw.write("你a好"); 
    fw.close(); 
    
    //4.void write(i nt b)//可以查API进行了解，这里就不赘述了

    ---

  • 字符输入流—>FileReader
    

    //FileReader输入文件2种成员方法
    // 1.int read(char[] cbuf)
    FileReader fr=new FileReader("a.txt");
    char[] chArr=new char[2];
    int len;
    while((len=fr.read(chArr))!=-1){ 
        System.out.println(new String(chArr,0,len));
        System.out.println(len);
    }
    fr.close();
    
    //2.int read()
    FileReader fr=new FileReader("GBK.txt");
    int ch;
    while((ch=fr.read())!=-1){
        System.out.println((char)ch);
    }
    fr.close();

  ---

• 转换流

  • 转换流的使用主要是构建字符流与字节流之间的桥梁，通过指定编码格式转换得到自己想要的结果。

    ---

  • 字符流通向字节流的桥梁—> OutputStreamWriter
    

    //OutputStreamWriter需要字节输出流
    FileOutputStream fos=new FileOutputStream("UTF-8.txt");
    OutputStreamWriter osw=new OutputStreamWriter(fos,"UTF-8");
    
    osw.write("你好");    
    osw.close();
    }

    ---

  • 字节流通向字符流的桥梁—>InputStreamReader
    

    //InputStreamReader需要字节输入流
    FileInputStream fis=new FileInputStream("UTF-8.txt");
    InputStreamReader isr=new InputStreamReader(fis,"UTF-8");
    
    int ch;
    while((ch=isr.read())!=-1){
        System.out.println((char)ch);
    }
    
    isr.close();

  ---

• 缓冲流

  • 用字符流和字节流读写数据量很大的文件时，速度会很慢，降低程序效率，缓冲流则可以用来提高IO流的读写速度。[上面字节流中复制文件的代码就是采用缓冲数组来实现增加读写速度，可以看做缓冲流的简陋版本]

    ---

  • 字节缓冲流

    • 缓冲输出流—>BufferedOutputStream

    

    //BufferedOutputStream缓冲输出文件3种成员方法
    //1.void write(byte[] b, int off, int len)  
    FileOutputStream fos=new FileOutputStream("buffer.txt");
    BufferedOutputStream bos = new BufferedOutputStream(fos);
    byte[] bArr={98,99,100,101,102};
    bos.write(bArr, 2, 2);
    bos.close();
    
    //2.void write(byte[] b) 
    FileOutputStream fos=new FileOutputStream("buffer.txt");
    BufferedOutputStream bos = new BufferedOutputStream(fos);
    byte[] bArr={97,98,99,100};
    bos.write(bArr);
    bos.close();
    
    //3.void write(int b)
    FileOutputStream fos=new FileOutputStream("buffer.txt");
    BufferedOutputStream bos = new BufferedOutputStream(fos);
    bos.write(97);
    bos.flush();
    bos.close();

    ---

    • 缓冲输入流—>BufferedInputStream

    

    //BufferedInputStream缓冲输入文件2种成员方法
    //1.int read(byte[])
    FileInputStream fis=new FileInputStream("buffer2.txt");
    BufferedInputStream bis=new BufferedInputStream(fis);
    byte[] bArr=new byte[3];
    int len=bis.read(bArr);//bArr={97,98,99}
    System.out.println(new String(bArr,0,len));
    System.out.println(len);
    bis.close();
    
    //2.int read()
    FileInputStream fis=new FileInputStream("buffer2.txt");
    BufferedInputStream bis=new BufferedInputStream(fis);
    int b=bis.read();
    System.out.println(b);
    bis.close();

    ---

    • 利用缓冲字节流高效拷贝图片

    //1.利用基本流关联文件
    FileInputStream fis=new FileInputStream("1.png");
    FileOutputStream fos=new FileOutputStream("copy.png");
    
    //2.对基本流进行高效
    BufferedInputStream bis=new BufferedInputStream(fis);
    BufferedOutputStream bos=new BufferedOutputStream(fos);
    
    //3.进行读写操作
    int b;
    while((b=bis.read())!=-1){
        bos.write(b);
    }
    
    //4.关流
    bos.close();
    bis.close();
    fos.close();
    fis.close();

    ---

  • 字符缓冲流

    • 缓冲输出流—>BufferedWriter

    

    //BufferedWriter缓冲输出文件4种成员方法
    //利用高效流做写操作 a你好abcbc
    BufferedWriter bw=new BufferedWriter(new FileWriter("buffer3.txt"));
    
    //1. void write(int c) 
    bw.write(97);
    
    //void newLine()--->换行标志
    bw.newLine();//bw.write("\r\n'')
    
    //2.void write(String str)
    bw.write("你好");
    
    char[] chArr={'a','b','c'};
    
    //3.void write(char[] cbuf)
    bw.write(chArr);
    
    //4.void write(char[] cbuf, int off, int len)
    bw.write(chArr,1,2);
    bw.close();

    ---

    • 缓冲输入流—>BufferedReader

    

    //BufferedReader缓冲输入文件3种成员方法
    BufferedReader br=new BufferedReader(new FileReader("buffer4.txt"));
    
    //1.int read()
    int ch=br.read();
    System.out.println(ch);//97
    
    //2.int read(char[] cbuf)
    char[] chArr=new char[2];
    int len=br.read(chArr);//chArr={'b','c'}
    System.out.println(new String(chArr));//"bc"
    System.out.println(len);//2
    
    //3.String readLine():读取一行数据,不会读该行的换行符
    String line;
    while((line=br.readLine())!=null){
        System.out.println(line);
    }
    br.close();

    ---

    • 字符缓冲流完成文本文件的复制

    //1.利用高效流,在高效流中传入基本流
    BufferedReader br=new BufferedReader(new FileReader("buffer5.txt"));
    BufferedWriter bw=new BufferedWriter(new FileWriter("copy.txt"));
    
    //2.循环的读写操作
    String line;
    while((line=br.readLine())!=null){
      bw.write(line);//第一循环 line="你好吗" 写入你好吗
                      //第二次循环 line="我很好" 写入我很好
                      //...
     bw.newLine();//写入一个换行
    }
    
    //3.关流释放资源
    br.close();
    bw.close();

  ---

• 序列化流和反序列化流

  • 序列化流和反序列化流是针对对象读写如文件这类问题，需要注意的是

    • 只有支持 java.io.Serializable 接口的对象才能读写入流中

    • 加static修饰的成员变量不会被序列化,原因是静态成员随着类的加载而加载,当没有对象的时候,静态成员已经存在静态成员不属于对象,而属于类

    • 如果非静态成员不想序列化:加一个transient,一旦使用该关键字该成员变量就不会被序列化

    • ***冲突与解决：
      1. 冲突: 对象序列化后会根据此时对象的变量，成员方法产生一个***同时写入，当反序列化时如果此时类的部分代码发生变动其***会发生改变，此时前后***不一致会报错。
      2. 解决：在需要序列化的类中手动定义***

      public class Person implements Serializable{
      
          //一旦手动添加***,就不会自动生成
          private static final long serialVersionUID = 1L;
      }

    ---

  • 序列化流—>ObjectOutputStream
    

    //ObjectOutputStream序列化对象 void write(Object obj)
    ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("person.txt"));
    
    //1.写入一个对象
    Person p=new Person("张三",10);
    oos.writeObject(p);
    
    //2.写入多个对象
    ArrayList<Person> al=new ArrayList<Person>();
    al.add(new Person("张三", 10));
    al.add(new Person("李四", 20));
    oos.writeObject(al);
    
    oos.close();

    ---

  • 反序列化—>ObjectInputStream

    

    //ObjectInputStream反序列化对象 void re ad(Object obj)
    ObjectInputStream ois=new ObjectInputStream(new FileInputStream("person.txt"));
    
    //1.从person.txt中读取一个Person对象
    Object obj= ois.readObject();//Object obj=new Person("张三",10)
    Person p=(Person)obj;
    System.out.println(p.getName()+" "+p.getAge());
    
    //2.从person.txt中读取多个Person对象
    ArrayList al=(ArrayList)(ois. readObject());
    for(Person p:al){
        System.out.println(p. getName()+"\t"+p. getAge());
    }
    ois. close();

  ---

• 打印流

  • 打印流同样分为字节打印流和字符打印流，由于打印流就是方便输出数据文件，所以只有输出端。

    ---

  • 字节打印流—>PrintStream
    

    ```
    //PrintStream打印部分成员方法(由于方法太多，只列举部分)
    PrintStream ps=new PrintStream(new FileOutputStream("print.txt"));
    
    //调用PrintStream方法写内容
    ps.write('a');
    ps.print(true);
    ps.print(100);
    ps.println('b');
    ps.println("你好");
    
    ps.close();
    ```
    

    ---

  • 字符打印流—>PrintWriter
    

    //PrintWriter打印部分成员方法(由于方法太多，只列举部分)
    PrintWriter pw=new PrintWriter(new FileOutputStream("print.txt"));
    
    //调用PrintWriter方法写内容
    pw.write('c');
    pw.print(false);
    pw.print(10);
    pw.println('b');
    pw.println("再见");
    
    pw.close();

    ---

  • 打印流完成数据自动刷新可以分为2种方法

    • 手动刷新:
      void flush();
      void close();[关流操作本身就是刷新和关闭的综合]

      PrintWriter pw=new PrintWriter(new FileOutputStream("print.txt"));
      pw.write('a');
      pw.print(true);
      pw.print(100);
      pw.println('b');
      pw.println("你好");
      
      //pw.flush();
      pw.close();

      ---

    • 自动刷新: [atuoFlush处为true时自动刷新]
      PrintStream(OutoutStream out,boolean autoFlush)
      PrintWriter(OutputStream out, boolean autoFlush)

      PrintWriter pw=new PrintWriter(new FileOutputStream("print.txt"),true);
      pw.println(true);
      pw.println("你好");
      pw.close();