IO输入/输出流（三）

前言：

Java中对数据进行持久化操作

转换流：

字节流与字符流之间转换的桥梁，可以用于改变字符的编码格式，编码统一，解决乱码问题

• 1 转换流OutputStreamWriter的写入（字节转字符）

  
  OutputStreamWriter类的构造方法.png

public class OutputStreamWriterDemo throws IOException{
  public static void main(String[] args){
    writeGBK();//UTF-8编码写入方法相同
  }
  //使用GBK编码形式写入
  public static void writeGBK() throws IOException{
    //创建字节输出流
    FileOutputStream fos = new FileOutputStream("c"\\gbk.txt");
    //创建转换流对象，构造方法，绑定字节输出流，指定GBK编码格式
    OutputStreamWriter osw = new OutputStreamWriter(fos,"GBK");
    //转换流写入数据
    osw.write("你好");  
    osw.flush();
    osw.close();
  }
}

• 2 转换流InputStreamReader的读取（字符转字节）

public class InputStreamReaderDemo throws IOException{
  public static void main(String[] args){
    readGBK();//UTF-8编码读取方法相同
  }
  //使用GBK编码形式读取
  public static void readGBK() throws IOException{
    //创建字节输出流
    FileInputStream fis = new FileInputStream("c"\\gbk.txt");
    //创建转换流对象，构造方法，绑定字节输入流，指定GBK编码格式
    InputStreamReader isr = new InputStreamReader(fis,"GBK");
    int len = 0;
    char[] ch = new char[1024];
    while((len = isr.read(ch)) != -1){
      System.out.println(new String(len));
    }
    isr.close();
  }
}

• 3 转换流和其子类的区别
  发现有如下继承关系：
  OutputStreamWriter:
  |--FileWriter:
  InputStreamReader:
  |--FileReader;
  OutputStreamWriter和InputStreamReader是字符和字节的桥梁：也可以称之为字符转换流。字符转换流原理：字节流+编码表。
  FileWriter和FileReader：作为子类，仅作为操作字符文件的便捷类存在。当操作的字符文件，使用的是默认编码表时可以不用父类，而直接用子类就完成操作了，简化了代码。
  InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"));//默认字符集。
  InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"),"GBK");//指定GBK字符集。
  FileReader fr = new FileReader("a.txt");
  这三句代码的功能是一样的，其中第三句最为便捷。
  注意：一旦要指定其他编码时，绝对不能用子类，必须使用字符转换流。什么时候用子类呢？
  条件：
  1、操作的是文件。2、使用默认编码。
  总结：
  字节--->字符 ： 看不懂的--->看的懂的。 需要读。输入流。 InputStreamReader
  字符--->字节 ： 看的懂的--->看不懂的。 需要写。输出流。 OutputStreamWriter

缓冲流：

内部包含了缓冲区，提高了IO流读写效率

• 1 字节输出缓冲流BufferedOutputStream

public class BufferedOutputStreamDemo{
  public static void main(String[] args) throws IOException{
    //创建字节输出流，绑定文件
    FileOutputStream fos = new FileOutputStream("c:\\test.txt");
    //创建字节输出流缓冲流的对象，构造方法中，传递字节输出流（OutputStream的子类）
    BufferedOutputStream bos = new BufferedOutputStream(fos);
    //写入字节和字节数组
    bos.write("65");//显示"A"
    bos.write("hello".getBytes());//显示"Ahello"
    //关闭缓冲流
    bos.close();
  }
}

• 2 字节输入缓冲流BufferedInputStream

public class BufferedIntputStreamDemo{
  public static void main(String[] args) throws IOException{
    //创建字节输入流，绑定文件
    FileInputStream fis = new FileInputStream("c:\\test.txt");
    //创建字节输入流缓冲流的对象，构造方法中，传递字节输入流（InputStream的子类）
    BufferedOutputStream bis = new BufferedOutputStream(fis);
    //读取字节
    byte[] bytes = new byte[1024];
    int len = 0;
    while((len = bis.read(bytes)) != -1){
      System.out.println(new String(bytes,0,len));
    }
    //关闭缓冲流
    bis.close();
  }
}

• 3 四种使用字节流文件复制的效率比较：

public class Copy{
  /*
  * 按效率排名：缓冲流读字节数组>字节流读字节数组>缓冲流读单个字节>字节流读单个字节
  */

  //使用字节流，读取单个字节
  public static void copy_1(File address1,File address2){
    FileInputStream fis = new FileInputStream(address1);
    FileOutputStream fos = new FileOutputStream(address2);
    int len = 0;
    while((len = fis.read()) != -1){
      fos.write(len);
    }
    fos.close();
    fis.close();
  }
  //使用字节流，读取字节数组
  public static void copy_2(File address1,File address2){
    FileInputStream fis = new FileInputStream(address1);
    FileOutputStream fos = new FileOutputStream(address2);
    int len = 0;
    byte[] bytes = new bytes[1024]
    while((len = fis.read()) != -1){
      fos.write(bytes,0,len);
    }
    fos.close();
    fis.close();
  }
  //使用缓冲字节流，读取单个字节
  public static void copy_3(File address1,File address2){
    BufferedInputStream bis = new BufferedInputStream(address1);
    BufferedOutputStream bos = new BufferedOutputStream(address2);
    int len = 0;
    while((len = fis.read()) != -1){
      fos.write(len);
    }
    bos.close();
    bis.close();
  }
  //使用缓冲字节流，读取字节数组
  public static void copy_3(File address1,File address2){
    BufferedInputStream bis = new BufferedInputStream(address1);
    BufferedOutputStream bos = new BufferedOutputStream(address2);
    int len = 0;
    byte[] bytes = new bytes[1024]
    while((len = fis.read()) != -1){
      fos.write(bytes,0,len);
    }
    bos.close();
    bis.close();
  }
}

• 4 字符输出缓冲流BufferedWriter

public class WriterDemo{
  public static void main(String[] args){
    //创建字符输出流，封装文件
    FileWriter fw = new FileWriter("c:\\test.txt");
    //创建字符输出流缓冲流的对象，构造方法中，传递字符输出流（Writer的子类）
    BufferedWriter bw = new BufferedWriter(fw);
    //写入字符
    bw.write(100);
    bw.flush();
    bw.newLine();//换行的作用，BufferedWriter特有的方法，同"\r\n"作用相同，但其具有跨平台型，不用考虑操作系统中的换行符
    bw.write("你好");
    bw.flush();//显示"d你好"
  }
}

• 5 字符输入缓冲流BufferedReader

public class ReaderDemo{
  public static void main(String[] args){
    //创建字符输入流，封装文件
    FileReader fr = new FileReader("c:\\test.txt");
    //创建字符输入流缓冲流的对象，构造方法中，传递字符输入流（Reader的子类）
    BufferedReader br = new BufferedReader(fr);
    //读取字符
    String line = null; 
    while((line = br.readLine() != null){
      //readLine()是BufferedReader的特有方法，读取一行的字符，但不包括换行符
      System.out.println(line);
    }
    br.close();
  }
}

• 4 字符缓冲流复制文件

public class Copy{
  public static void main(String[] args){
    BufferedReader br = new BufferedReader("c:\\test.txt");
    BufferedWriter bw = new BufferedWriter("d:\\test.txt");
    String line = null;
    while((br.readLine()) != null){
      bw.write(line);
      bw.newLine();
      bw.flush();
    }
    bw.close();
    br.close();
  }
}

IO流的操作规律：

• 1 明确一：要操作的数据是数据源还是数据目的。（先根据需求明确要读，还是要写）
  源：
  InputStream
Reader
  目的：
  OutputStream
Writer
• 2 明确二：要操作的数据是字节还是文本呢？
  源：
  字节：InputStream
文本：Reader
  目的：
  字节：OutputStream
文本：Writer
• 3 明确三：明确数据所在的具体设备。（完全可以明确具体要使用哪个流对象）
  源设备：
  硬盘：文件 File开头
内存：数组，字符串
键盘：System.in
网络：Socket
  目的设备：
  硬盘：文件 File开头
内存：数组，字符串
屏幕：System.out
网络：Socket
• 4 明确四：是否需要额外功能呢？（已经明确到了具体的体系上）
  额外功能：
  转换吗？转换流。InputStreamReader OutputStreamWriter
高效吗？缓冲区对象。BufferedXXX