上一篇：IO流之文件字符输出流【FileWriter】 https://www.jianshu.com/p/579ea78e5bae

1、概述

缓冲流,也叫高效流，是对4个基本的 FileXxx 流的增强，所以也是4个流，按照数据类型分类：

• 字节缓冲流： BufferedInputStream、BufferedOutputStream
• 字符缓冲流： BufferedReader、BufferedWriter
  缓冲流的基本原理，是在创建流对象时，会创建一个内置的默认大小的缓冲区数组，通过缓冲区读写，减少系统IO 次数，从而提高读写的效率。

2、字节缓冲流

2.1 BufferedOutputStream【字节缓冲输出流】

BufferedOutputStream extends FilterOutputStream extends OutputStream
继承自父类的成员方法：

• void close()：关闭此输出流并释放与此流相关联的任何系统资源。
• void flush()：刷新此输出流并强制任何缓冲的输出字节被写出。
• void write(byte[] b)：将 b.length字节从指定的字节数组写入此输出流。
• void write(byte[] b, int off, int len)：从指定的字节数组写入 len个字节，从偏移 off开始输出到此输出流。
• abstract void write(int b)：将指定的字节写入此输出流。

2.1.1 构造方法

• BufferedOutputStream(OutputStream out)
  创建一个新的缓冲输出流，以将数据写入指定的底层输出流。
• BufferedOutputStream(OutputStream out, int size)
  创建一个新的缓冲输出流，以便以指定的缓冲区大小将数据写入指定的底层输出流

2.1.2 参数：

• OutputStream out：字节输出流
• int size：指定缓冲区内部缓冲区的大小，默认值为：8192
  构造举例，代码如下：

//创建文件字节输出流
 FileOutputStream os = new FileOutputStream("IO流//e.txt");
// 创建字节缓冲输出流 
BufferedOutputStream bos= new BufferedOutputStream(os);
BufferedOutputStream bos2= new BufferedOutputStream(os,5);

2.1.3、写出数据

public static void main(String[] args) throws Exception {
        //创建FileOutputStream对象，构造方法中绑定要输出的目的地
        FileOutputStream os = new FileOutputStream("IO流//e.txt");
        //创建BufferedOutputStream对象，构造方法中传递FileOutputStream对象，提高FileOutputStream对象效率
        BufferedOutputStream bos = new BufferedOutputStream(os);
        //使用BufferedOutputStream对象中的方法write方法，把数据写入到内部缓冲区中
        bos.write("测试字节缓冲输出流".getBytes());
        //把内部缓冲区中的数据，刷新到文件中
        bos.flush();
        //是否资源（会先把内存缓冲区的数据，刷新到文件中）
        bos.close();
    }

2.2 BufferedInputStream【字节缓冲输入流】

BufferedInputStream extends FilterInputStream extends InputStream
继承自父类的成员方法：

• void close()：关闭此输入流并释放与流相关联的任何系统资源。
• abstract int read()：从输入流读取数据的下一个字节。
• int read(byte[] b)：从输入流读取一些字节数，并将它们存储到缓冲区 b 。
• int read(byte[] b, int off, int len)：从输入流读取最多 len字节的数据到一个字节数组。

2.2.1 构造方法

• BufferedInputStream(InputStream in)
  创建一个 BufferedInputStream并保存其参数，输入流 in ，供以后使用。
• BufferedInputStream(InputStream in, int size)
  创建 BufferedInputStream具有指定缓冲区大小，并保存其参数，输入流 in ，供以后使用。

2.2.2 参数：

• InputStream in：字节输入流
• int size：指定缓冲区内部缓冲区的大小，默认值为：8192
  构造举例，代码如下：

//创建文件字节输入流
  FileInputStream fs = new FileInputStream("IO流\\e.txt");
//创建字节缓冲输入流
  BufferedInputStream bis = new BufferedInputStream(fs);
  BufferedInputStream bis2 = new BufferedInputStream(fs,5);

2.2.3 读取数据

//创建FileInputStream对象，绑定要读取的数据源
        FileInputStream fs = new FileInputStream("IO流\\e.txt");
        //创建BufferedInputStream对象，构造方法中传递FileInputStream对象，提高FileInputStream对象的读取效率
        BufferedInputStream bis = new BufferedInputStream(fs);
        //存储每次读取的数据
        byte[] bytes = new byte[102];
        int len = 0; //记录每次读取的有效字节个数
        //使用BufferedInputStream对象中的方法read，读取文件
        while((len = bis.read(bytes)) != -1){
            System.out.println(new String(bytes,0,len));
        }
        bis.close();
        fs.close();
    }

效率测试
查询API，缓冲流读写方法与基本的流是一致的，我们通过复制大文件（79.2 MB ），测试它的效率。
1. 基本流，代码如下:

 public static void main(String[] args) throws Exception{
        long startTime = System.currentTimeMillis();
        //创建FileInputStream对象
        FileInputStream fis = new FileInputStream("D:\\dev\\1.jpg");
        //创建FileOutputStream对象
        FileOutputStream fos = new FileOutputStream("D:\\dev\\2.jpg");
        //一次读取多个字节的方式
        byte[] bytes = new byte[1024];
        int len = 0;
        while((len = fis.read(bytes)) != -1){
            //使用方法write(),将读取的流写入到目的地的文件中
            fos.write(bytes,0,len);
        }
        //释放资源，先关闭写的(如果写完了，肯定读完了)
        fos.close();
        fis.close();
        long endTime = System.currentTimeMillis();
        System.out.println("文件复制共耗时：" + (endTime - startTime) + "毫秒");
    }

输出结果：文件复制共耗时：2103毫秒

2. 缓冲流，代码如下：

 public static void main(String[] args) throws Exception {
        long startTime = System.currentTimeMillis();
        //创建流对象
        try(BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\安装包\\SecureCRT72.zip"));
            BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:\\安装包\\SecureCRT744442.zip"));)
        {
            // 读写数据
            int len = 0;
            byte[] b = new byte[1024];
            while ((len = bis.read(b)) != -1){
                bos.write(b,0,len);
            }
        }catch (IOException e){
            e.printStackTrace();
        }

        long endTime = System.currentTimeMillis();
        System.out.println("缓冲流复制时间:"+(endTime - startTime)+" 毫秒");
    }


输出结果：缓冲流复制时间:378 毫秒

2.3 BufferedWriter【字符缓冲输出流】

BufferedWriter extends Writer
继承自父类的成员方法：

• abstract void close()：关闭流，但要先刷新。
• abstract void flush()：刷新流。
• void write(int c)：写一个字符
• void write(char[] cbuf)：写入一个字符数组。
• void write(char[] cbuf, int off, int len)：写入字符数组的一部分。
• void write(String str)：写一个字符串
• void write(String s, int off, int len)：写一个字符串的一部分。
  特有成员方法：
• void newLine:写一行行分隔符。 会根据不同的操作系统，获取不同的行分隔符。win:\r\n linux:\n mac:\r

2.3.1 构造方法

• BufferedWriter(Writer out)
  创建使用默认大小的输出缓冲区的缓冲字符输出流。
• BufferedWriter(Writer out, int sz)
  创建一个新的缓冲字符输出流，使用给定大小的输出缓冲区。

2.3.2 参数：

Writer out：字符输出流
int sz：指定缓冲区内部缓冲区的大小，默认值为：8192
构造举例，代码如下：

//创建FileWriter文件字符输出流对象
 FileWriter fw = new FileWriter("IO流\\f.txt");
//创建字符缓存输出流对象
 BufferedWriter bw = new BufferedWriter(fw);
 BufferedWriter bw2 = new BufferedWriter(fw,6);

2.3.3 写数据

  public static void main(String[] args) throws IOException {
        FileWriter fw = new FileWriter("IO流\\f.txt");
        BufferedWriter bw = new BufferedWriter(fw);
        for (int i = 0; i < 10; i++) {
            bw.write("你好棒哦");
            //换行
            bw.newLine();
        }
        bw.flush();
        bw.close();
    }


输出结果：
你好棒哦
你好棒哦
你好棒哦
你好棒哦
你好棒哦
你好棒哦
你好棒哦
你好棒哦
你好棒哦
你好棒哦

2.4 BufferedReader【字符缓冲输入流】

BufferedReader extends Reader
继承自父类的成员方法：

• void close()：关闭流并释放与之相关联的任何系统资源。
• int read()：读一个字符
• int read(char[] cbuf, int off, int len)：将字符读入数组的一部分。
  特有成员方法：
  String readLine:读一行文字。一行被视为由换行符（'\ n'），回车符（'\ r'）中的任何一个或随后的换行符终止。
  返回值：
  包含行的内容的字符串，不包括任何行终止字符，如果已达到流的末尾，则为null

2.3.1 构造方法

• BufferedReader(Reader in)
  创建使用默认大小的输入缓冲区的缓冲字符输入流。
• BufferedReader(Reader in, int sz)
  创建使用指定大小的输入缓冲区的缓冲字符输入流。

2.3.2 参数

• Reader in：字符输入流
• int sz：指定缓冲区内部缓冲区的大小，默认值为：8192
  构造举例，代码如下：

//创建文件字符输入流
  FileReader fr = new FileReader("IO流\\f.txt");
 //创建字符缓冲输入流
  BufferedReader br = new BufferedReader(fr);
  BufferedReader br2 = new BufferedReader(fr,5);

2.3.3 读取数据

使用readLine方法读

   public static void main(String[] args) throws Exception {
        //// 创建流对象
        FileReader fr = new FileReader("IO流\\f.txt");
        BufferedReader br = new BufferedReader(fr);
      // 定义字符串,保存读取的一行文字
        String line = null;
     // 循环读取,读取到最后返回null
        while ((line = br.readLine()) != null){
            System.out.println(line);
        }
      // 释放资源 
      br.close();
    }

下一篇：IO流之转换流 https://www.jianshu.com/p/bcf14a231b65