java缓冲流

概述

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

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

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

BufferedOutputStream

java.io.BufferedOutputStream extends OutputStream

BufferedOutputStream: 字节缓冲输入流

继承自父类的共性成员方法：

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

构造方法：

• BufferedOutputStream(OutputStream out): 创建一个新的缓冲输出流，以将数据写入指定的底层输出流。
• BufferedOutputStream(OutputStream out, int size)：创建一个新的缓冲输出流，已将具有指定缓冲区大小的数据写入指定的底层
• 参数：
  • OutputStream out: 字节输出流：我们可以传递FileOutputStream,缓冲流会给FileOutputStream增加一个缓冲区，提高FileOutputStream的写入效率
  • int size: 指定缓冲区的大小，不指定默认
• 使用步骤：
  1. 创建FileOutputStream对象，构造方法中绑定要输出的目的地
  2. 创建BufferedOutputStream对象，构造方法中传递FileOutputStream对象，提高FileOutputStream对象的效率
  3. 使用BufferedOutputStream对象中的方法write,把数据写入到内部缓冲区中
  4. 使用BufferedOutputStream对象中的flush，把内部缓冲区的数据，刷新到文件中
  5. 释放资源（会先调用flush方法刷新数据，第4步可以省略）

BufferedInputStream

字节缓冲输入流，类似字节缓冲输出流

构造方法：

• BufferedInputStream(InputStream in) 创建一个BufferedInputStream并报存其参数，即输入流in,以便将来使用
• BufferedInputStream(InputStream in,int size) 创建一个指定缓冲区大小的BufferedInputStream并报存其参数，即输入流in,以便将来使用

使用步骤：

1. 创建FileInputStream对象，构造方法中绑定要读取的数据源
2. 创建BufferedInputStream对象，构造方法中传递FileInputStream对象，提高FileInputStream对象的读取效率
3. 使用BufferedInputStream对象中的方法read,读取文件
4. 释放资源

关闭

关闭缓冲流自动就会把基本的流给关闭掉。

使用字节缓冲流案例

文件复制案例+效率测试

public class Demo01Buffered {
    public static void main(String[] args) throws IOException {
        long start;
        long end;
        // 第一种：单个字节读
        start = System.nanoTime();
        InputStream is1 = new FileInputStream("G:\\test1\\aa.png");
        OutputStream os1 = new FileOutputStream("G:\\test1\\cc.png");
        int len = 0;
        while((len=is1.read())!=-1){
            os1.write(len);
        }
        os1.close();
        is1.close();
        end = System.nanoTime();
        System.out.println("第一种" + (end-start)+"ns");

        // 第二种使用缓冲数组
        start = System.nanoTime();
        InputStream is2 = new FileInputStream("G:\\test1\\aa.png");
        OutputStream os2 = new FileOutputStream("G:\\test1\\dd.png");
        byte[] bytes = new byte[1024];
        while((len=is2.read(bytes))!=-1){
            os2.write(bytes,0,len);
        }
        os2.close();
        is2.close();
        end = System.nanoTime();
        System.out.println("第二种" + (end-start)+"ns");


        // 第三种使用缓冲区
        start = System.nanoTime();
        InputStream is = new FileInputStream("G:\\test1\\aa.png");
        OutputStream os = new FileOutputStream("G:\\test1\\ee.png");
        BufferedInputStream bis = new BufferedInputStream(is,1024*8);
        BufferedOutputStream bos = new BufferedOutputStream(os,1024*8);
        while((len = bis.read(bytes))!=-1){
            bos.write(bytes,0,len);
        }
        bos.close();
        bis.close();
        end = System.nanoTime();
        System.out.println("第三种" + (end-start)+"ns");
    }
}

字符缓冲流

字符缓冲流的使用十分类似，接收和处理的对象不是字节了，而是字符或者字符串了，可以参看如上。