IO流(2)缓冲流：增强型字节流、字符流

一、缓冲流概述

是对前面学习的4个基础的字节字符流的增强

• FileOutputStream
• FileInputStream
• FileWriter
• FIleReader

1. 缓冲流的基本原理

• 1.使用底层流对象从具体设备上获取数据，并将数存储到缓冲区的数据内
• 2.通过缓冲区的read()方法从缓冲区获取具体的字符数据，这样就提高了效率
• 3.如果用read方法读取字符数据，并存储到另一个容器，直到读取到了换行符时，将另一个容器临时存储的数据转换为字符串返回，就形成了readLine()方法

综上，也就是说，在创建流对象的时候，会创建一个内置的默认大小的缓冲区数组，通过缓冲区读写，减少系统IO次数，从而提高读写效率

缓冲流的命名规律是BufferedXXX

• 字节缓冲流：BufferedInputStream,BufferedOutputStream
• 字符缓冲流：BufferedWriter,BufferedReader

二、字节缓冲流

1. 构造方法

• public BufferedInputStream(InputStream in)：创建一个新得缓冲输入流、注意参数类型是InputStream
• public BufferedOutputStream(OutputStream out)：创建一个新得缓冲输出流，注意参数类型是OutputStream

常见写法

public class Buffered_Demo01 {
    public static void main(String[] args) throws FileNotFoundException {
        //0. 方式一
        FileInputStream fis = new FileInputStream("b.txt");
        BufferedInputStream bis = new BufferedInputStream(fis);

        //1. 方式二
        BufferedInputStream bis2 = new BufferedInputStream(new FileInputStream("c.txt"));

        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("d.txt"));

    }
}

2. 缓冲流的高效性（缓冲流实现大文件的复制）

• 缓冲流的读写方法和普通的基本一致，下面通过复制一个大文件来对比普通字节流和缓冲流的区别

• 文件信息
  

• 普通字节流复制文件

public class Buffered_Demo02 {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        //0. 声明 字节输入流输出流
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            //1. 创建输入流
            fis = new FileInputStream("D:\\IO流学习\\test.mkv");
            //2. 创建输出流
            fos = new FileOutputStream("D:\\IO流学习\\test_copy.mkv");
            //3. 创建大小为1MB的字节数组
            byte[] b = new byte[1024];
            int len;
            while ((len = fis.read(b)) != -1){
                fos.write(b,0,len);
            }
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            try {
                fis.close();
                fos.close();
            }catch (IOException e){
                e.printStackTrace();
            }
        }
        System.out.println("普通流复制300M文件耗时：" + (System.currentTimeMillis() - start));
    }
}

• 缓冲流复制文件

public class Buffered_Demo03 {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        //0. 声明 字节缓冲输入流输出流
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            //1. 创建缓冲输入流
            bis = new BufferedInputStream(new FileInputStream("D:\\IO流学习\\test.mkv"));
            //2. 创建缓冲输出流
            bos = new BufferedOutputStream(new FileOutputStream("D:\\IO流学习\\test_copy02.mkv"));
            //3. 创建大小为1MB的字节数组
            byte[] b = new byte[1024];
            int len;
            while ((len = bis.read(b)) != -1){
                bos.write(b,0,len);
            }
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            try {
                bis.close();
                bos.close();
            }catch (IOException e){
                e.printStackTrace();
            }
        }
        System.out.println("缓冲流复制300M文件耗时：" + (System.currentTimeMillis() - start));
    }
}

• 耗时对比
  

三、字符缓冲流

1. 构造方法

格式和原理与字节缓冲流完全一致

• public BufferedReader(Reader in)：创建一个新的缓冲输入流，注意参数类型为Reader
• public BufferedWriter(Writer out)：创建一个新的缓冲输出流，注意参数类型为Writer

2. 字符缓冲流特有方法(readLine()/writeLine())

基本的读写方法和普通字符流完全一致

• BufferedReader:public String readLine()按行读取数据，读到最后返回null
• BufferedWriter:public void newLine()：换行，由系统属性定义符号

2.1 readLine()

public class Buffered_Demo04 {
    public static void main(String[] args) throws IOException {
       //0. 创建缓冲字符输入流
        BufferedReader br = new BufferedReader(new FileReader("D:\\IO流学习\\a.txt"));
        //1. 定义暂存字符串
        String line = null;
        while ((line = br.readLine()) != null){
            System.out.print(line);
            System.out.println();
        }
    }
}

• 输出
  

2.2 newLine()

public class Buffered_Demo05 {
    public static void main(String[] args) throws IOException {
       //0. 创建缓冲字符输入流
        BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\IO流学习\\a.txt"));
        bw.write("换行");
        bw.newLine();
        bw.write("写入");
        bw.newLine();
        bw.write("是可以的");
        bw.close();
    }
}

• 输出
  

3. 缓冲字符流实现对文本的排序

public class Buffered_Demo06 {
    public static void main(String[] args) throws IOException {
        Map<String, String> map = new HashMap<>();
        //0. 创建缓冲字符输入流
        BufferedReader br = new BufferedReader(new FileReader("D:\\IO流学习\\unSorted.txt"));
        BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\IO流学习\\Sorted.txt"));
        //1. 读取数据
        String line = null;
        while ((line = br.readLine()) != null){
            //1.1 按 . 作为分割符
            String[] split = line.split("\\.");
            map.put(split[0],split[1]);
        }
        br.close();
        //2. 遍历map集合
        for (int i = 1; i <= map.size(); i++) {
            String key = String.valueOf(i);
            //2.1 获取文本
            String value = map.get(key);
            //2.2 拼接写入
            bw.write(key + "." + value);
            //2.3 换行
            bw.newLine();
        }
        bw.close();
    }
}

• 输出