通过手写实际的代码案例理解Java I/O的缓冲流

概念

在基本的字节输入输出流或字符输入输出流，是通过JVM与操作系统直接与文件打交道，每次操作时，都需要进行硬盘读取或写入，效率低且速度慢。
java i/o缓冲流的引入，是在原有输入输出流的基础上增加一个缓冲区(底层数据结构为数组)，缓冲区的引入，减少了程序与硬盘文件读写的次数，可以极大地提高效率。

字节缓冲流

BufferedInputStream

• 构造方法
  – BufferedInputStream(InputStream in)：创建一个新的缓冲输入流，指向底层字节输入流
  – BufferedInputStream(InputStream in,int size) ：创建一个新的缓冲输入流，指定的底层字节输入流按指定的大小读入到缓冲区中
• 使用方法：
  – 1. 创建FileInputStream对象，构造方法中缓定要读取的字节文件
  – 2. 创建BufferedOutputStream对象，构造方法中传递FileInputStream对象，
  – 3. 使用BufferedOutputStream对象中的方法read，把数据读取到内部缓冲区中
  – 4. 释放资源

/**
 * 字节缓冲输入流的例子
 *
 * @author zhuhuix
 * @date 2020-06-25
 */
public class BufferedInputStreamDemo {
    public static void main(String[] args) throws IOException {
        FileInputStream fileInputStream = new FileInputStream("c:\\aaa.txt");
        BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
        byte[] bytes=new byte[1024];
        while (bufferedInputStream.read(bytes)!=-1){
            System.out.println(bytes);
        }
        bufferedInputStream.close();
    }
}

BufferedOutputStream

• 构造方法
  – BufferedOutputStream(OutputStream out)：创建一个新的缓冲输出流，将数据写入指定的底层字节输出流
  – BufferedOutputStream(OutputStream out,int size) ：创建一个新的缓冲输出流，将具有指定缓冲区大小的数据写入指定的底层字节输出流

• 使用方法：
  – 1. 创建FileOutputStream对象，构造方法中指定输出的文件目的地
  – 2. 创建BufferedOutputStream对象，构造方法中传递FileOutputStream对象，
  – 3. 使用BufferedOutputStream对象中的方法write，把数据写入到内部缓冲区中
  – 4. 使用BufferedOutputStream对象中的方法flush,把内部缓冲区中的数据写入到文件
  – 5. 释放资源

/**
 * 字节缓冲输出流的例子
 *
 * @author zhuhuix
 * @date 2020-06-25
 */
public class BufferedOutputStreamDemo {

    public static void main(String[] args) throws IOException {
        FileOutputStream fileOutputStream = new FileOutputStream("c:\\aaa.txt");
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
        bufferedOutputStream.write("把字节数据写入到缓冲区".getBytes());
        bufferedOutputStream.flush();
        bufferedOutputStream.close();
    }

}

字节缓冲流的实际例子

• 通过缓冲流进行文件复制

/**
 * 使用字节缓冲流进行文件复制的例子
 *
 * @author zhuhuix
 * @date 2020-06-25
 */
public class BufferedStreamExample {
    public static void main(String[] args) throws IOException {
        long start = System.currentTimeMillis();

        FileInputStream fileInputStream = new FileInputStream("c:\\data.dat");
        BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);

        FileOutputStream fileOutputStream = new FileOutputStream("c:\\data.dat.copy");
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);

        byte[] bytes = new byte[1024];
        while(bufferedInputStream.read(bytes)!=-1){
            bufferedOutputStream.write(bytes);
        }

        bufferedOutputStream.close();
        bufferedInputStream.close();

        long end = System.currentTimeMillis();
        System.out.println("复制文件共耗时："+(end-start+"ms"));
    }
}

字符缓冲流

BufferedWriter

• 构造方法
  – BufferedWriter(Writer out)：创建一个使用默认大小缓冲区的缓冲字符输出流
  – BufferedWriter(Writer out，int size)：创建一个指定大小缓冲区的缓冲字符输出流

• 特有的成员方法
  void newLine()：写入一个行分隔符（该方法会根据不同的操作系统 ，获了不同的行分隔符）。
  windows"\r\n；
  linux: /n ；
  mac:/r

• 使用方法：
  – 1. 创建FileWriter对象，构造方法中指定输出的文件目的地
  – 2. 创建BufferedWriter对象，构造方法中传递FileWriter对象，
  – 3. 使用BufferedWriter对象中的方法write，把数据写入到内部缓冲区中;使用方法newLine给字符行加上结束标记。
  – 4. 使用BufferedWriter对象中的方法flush,把内部缓冲区中的数据写入到文件
  – 5. 释放资源

/**
 * 字符缓冲输出流的例子
 *
 * @author zhuhuix
 * @date 2020-06-25
 */
public class BufferedWriterDemo {
    public static void main(String[] args) throws IOException {
        FileWriter fileWriter = new FileWriter("c:\\ccc.txt");
        BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
        bufferedWriter.write("字符缓冲输出流的例子的第一行");
        bufferedWriter.newLine();
        bufferedWriter.write("字符缓冲输出流的例子的第二行");
        bufferedWriter.newLine();
        bufferedWriter.flush();
        bufferedWriter.close();
    }

}

BufferedReader

• 构造方法
  – BufferedReader(Reader in)：创建一个使用默认大小缓冲区的缓冲字符输入流
  – BufferedReader(Reader in，int size)：创建一个指定大小缓冲区的缓冲字符输入流
• 使用方法：
  – 1. 创建FileReader对象，构造方法中指定要读取的文件目的地
  – 2. 创建BufferedReader对象，构造方法中传递FileReader对象，
  – 3. 使用BufferedReader对象中的方法read或readLine，把数据读取到内部缓冲区中
  – 4. 释放资源

• 特有的成员方法
  String readLine()：读取一行字符串。
  注意：返回值中不包含结束符号。

/**
 * 字符缓冲输入流的例子
 *  * @author zhuhuix
 * @date 2020-06-25
 */
public class BufferedReaderDemo {
    public static void main(String[] args) throws IOException {
        FileReader fileReader = new FileReader("c:\\ccc.txt");
        BufferedReader bufferedReader = new BufferedReader(fileReader);
        String s;
        while((s= bufferedReader.readLine())!=null){
            System.out.println(s);
        }
       bufferedReader.close();
    }
}

字符缓冲流的实际例子

• 读取文本文件中的四字成语，倒序排列后，复制到新的文件中。
  

/**
 * 字符缓冲流的实际案例
 *
 * @author zhuhuix
 * @date 2020-06-25
 */
public class BufferedReaderWriterDemo {

    public static void main(String[] args) throws IOException {
        // 存放成语
        List<String> list = new ArrayList<>();

        // 读取源文件，按顺序存放到list中
        FileReader fileReader = new FileReader("c:\\成语.txt");
        BufferedReader bufferedReader = new BufferedReader(fileReader);
        String s;
        while ((s = bufferedReader.readLine()) != null) {
            System.out.println(s);
            list.add(s);
        }
        bufferedReader.close();

        // 将list中的成语倒序回写到的原文件中
        FileWriter fileWriter = new FileWriter("c:\\成语.txt.");
        BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
        for (int i = list.size() - 1; i >= 0; i--) {
            bufferedWriter.write(list.get(i));
            bufferedWriter.newLine();
        }
        bufferedWriter.close();
    }

}

通过转换流去除中文乱码

• 由于FileReader,FileWriter处理文件时，使用的是"utf-8"编码格式的默认码表，对中文编码为"GBK"格式的文件进行读取写入时会造成中文乱码，我们可以使用Java IO提供的转换流进行指定编码格式的转换。

/**
 * 字符缓冲流的实际案例--字节流转换为指定编码方式的字符流
 *
 * @author zhuhuix
 * @date 2020-06-25
 */
public class BufferedReaderWriterDemo {

    public static void main(String[] args) throws IOException {
        // 存放成语
        List<String> list = new ArrayList<>();

        // 读取源文件，按顺序存放到list中
        InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream("c:\\phrase.txt"),"GBK");
        BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
        String s;
        while ((s = bufferedReader.readLine()) != null) {
            System.out.println(s);
            list.add(s);
        }
        bufferedReader.close();

        // 将list中的成语倒序回写到的新的拷贝文件中
        OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream("c:\\phrase.copy.txt."),"GBK");
        BufferedWriter bufferedWriter = new BufferedWriter(outputStreamWriter);
        for (int i = list.size() - 1; i >= 0; i--) {
            bufferedWriter.write(list.get(i));
            bufferedWriter.newLine();
        }
        bufferedWriter.close();
    }

}