Java 缓冲流

课堂案例

import java.io.*;

/**
 * 使用缓冲流提升的读写效率
 * copy案例2
 */
public class Demo06 {
    public static void main(String[] args) throws IOException {
        // 耗时：35196毫秒(低级流)
        // 耗时：508毫秒 （使用缓冲流）
        // 耗时：34毫秒 （使用了 byte数组批量读写）
        long start = System.currentTimeMillis();
            // 低级流
        FileInputStream  fis = new FileInputStream("和平精英.mp4");
        // 缓冲流-高级流中的一种，依赖于低级流
        BufferedInputStream bis = new BufferedInputStream(fis);
        // 写出的文件流
        FileOutputStream  fos = new FileOutputStream("荒野求生.mp4");
        BufferedOutputStream bos = new BufferedOutputStream(fos);

        byte[] data = new byte[1024 * 200];
        int l = -1;
            // fis.read() 一次读取一个字节,返回值为实际读取的一个字节的数据
            while((l=bis.read(data)) != -1){
                bos.write(data,0,l);
            }
            // 将最后的数据从缓冲区中一次写出
           bis.close();
            // 在关闭缓冲流时会自动调用flush函数清空缓冲区
           bos.close();
        long end = System.currentTimeMillis();
        System.out.println("耗时："+(end-start)+"毫秒");
    }
}

缓冲流概述

缓冲流，也叫高效流。能够高效读写缓冲流，能够转换编码的转换流，能够持久化存储对象的序列化对象等等。它是四个基本File流的增强，所以也是4个流，按照数据类型分类。

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

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

字节缓冲流

构造方法

BufferedInputStream(InputStream in)
BufferedInputStream(InputStream in, int size)
// 创建一个新的字节缓冲输入流
 
BufferedOutputStream(OutputStream out) // 将数据写入指定的底层输出流
BufferedOutputStream(OutputStream out, int size) // 将具有指定缓冲区大小的数据写入指定的底层输出流
// 创建一个新的字节缓冲输出流
参数：
InputStream in：字节输入流
OutputStream out：字节输出流
int size：缓冲区大小，不写的话，默认

BufferedOutputSteram——字节缓冲输出流

例子：把数据写到文件中：

1.创建FileOutputStream对象，构造方法中绑定要输出的目的地。
2.创建BufferedOutputStream对象，构造方法中传递FileOutputStream对象，提高FileOutputStream对象效率。
3.使用BufferedOutputStream对象中的方法write，把数据写入到内部冲区中。
4.使用BufferedOutputStream对象中的方法flush，把内部冲区中的数据，刷新到文件中。
5.释放资源（会先调用flush方法刷新数据，第4步可以省略）。
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
 
public class DemoBufferedOutputStream {
    public static void main(String[] args) throws IOException {
        method();
    }
 
    public static void method() throws IOException {
        // 创建FileOutputStream对象，构造方法中绑定要输出的目的地。
        FileOutputStream fos = new FileOutputStream("/Users/liyihua/IdeaProjects/Study/src/view/study/demo33/BufferedOutputStream.txt", true);
 
        // 创建BufferedOutputStream对象，构造方法中传递FileOutputStream对象，提高FileOutputStream对象效率。
        BufferedOutputStream bos = new BufferedOutputStream(fos);
 
        // 使用BufferedOutputStream对象中的方法write，把数据写入到内部冲区中。
        byte[] bytes = "abc".getBytes();
        bos.write(bytes);
 
        // 使用BufferedOutputStream对象中的方法flush，把内部冲区中的数据，刷新到文件中。
        bos.flush();
 
        // 释放资源（会先调用flush方法刷新数据，第4步可以省略）。
        bos.close();
        fos.close();
 
    }
}

BufferedInputStream——字节缓冲输入流

例子：读取以上生成的文件：

1.创建FileInputStream对象，构造方法中绑定要读取的效据源。
2.创建BufferedInputStream对象，构造方法中传递FileInputStream对象，提高FileInputsStream对象的读取效率
3.使用BufferedInputStream对象中的方法read，读取文件。
4.释放资源。
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
 
public class DemoBufferedInputStream {
    public static void main(String[] args) throws IOException {
        method();
    }
 
    private static void method() throws IOException {
        // 创建FileInputStream对象，构造方法中绑定要读取的效据源。
        FileInputStream fis = new FileInputStream(
                "/Users/liyihua/IdeaProjects/Study/src/view/study/demo33/BufferedOutputStream.txt"
        );
 
        // 创建BufferedInputStream对象，构造方法中传递FileInputStream对象，提高FileInputsStream对象的读取效率
        BufferedInputStream bis = new BufferedInputStream(fis);
 
        // 使用BufferedInputStream对象中的方法read，读取文件。
        int len1 = bis.read();
        System.out.println(len1);
 
        int len2 = bis.read();
        System.out.println(len2);
 
        int len3 = bis.read();
        System.out.println(len3);
 
        // 第四次读取的时候，所以的字节都已经给读取过了，返回-1
        int len4 = bis.read();
        System.out.println(len4);
 
        // 释放资源
        bis.close();
        fis.close();
    }
}