IO流 - 缓冲流

与时俱哉

于 2024-02-08 17:21:28 发布

阅读量508

点赞数 5

文章标签： java 开发语言

本文链接：https://blog.youkuaiyun.com/SU_mu147/article/details/136070807

版权

IO流 - 缓冲流

字节缓冲流

对原始流进行包装，以提高原始流读写数据的性能

字节输入缓冲流	字节输出缓冲流	字符输入缓冲流	字符输出缓冲流
BufferedInputStream	BufferedOutputStream	BufferedReader	BufferedWriter

字节缓冲流的作用

提高字节流读取数据的性能

原理：字节缓冲输入流自带了8KB缓冲池；字节缓冲输出流也自带了8KB缓冲池。

构造器	说明
public BufferedInputStream（InputStream is）	把低级的字节输入流包装成一个高级的缓冲字节输入流，从而提高读数据的性能
public BufferedOutputStream （OutputStream os）	把低级的字节输出流包装成一个高级的缓冲字节输出流，从而提高写数据的性能

import java.io.*;

public class Test {
    public static void main(String[] args) throws Exception {
        try (
                InputStream is = new FileInputStream("src\\com\\abc.txt");
                // 定义一个字节缓冲输入流包装原始的字节输入流
                InputStream bis = new BufferedInputStream(is,8192 * 2);

                OutputStream os = new FileOutputStream("src\\com\\xyz.txt");
                // 定义一个字节缓冲输出流包装原始的字节输出流
                OutputStream bos = new BufferedOutputStream(os);
        ) {
            byte[] bytes = new byte[1024];
            int len;
            while ((len = bis.read(bytes)) != -1){
                bos.write(bytes,0,len);
            }
            System.out.println("复制完成");

        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

字符缓冲流

BufferedReader（字符缓冲输入流）

作用：自带8KB（8192）的字符缓冲池，可以提高字符输入流读取字符数据的性能

构造器	说明
public BufferedReader（Reader r）	把低级的字符输入流包装成字符缓冲输入流管道，从而提高字符输入流读字符数据的性能

字符缓冲输入流新增的功能：按照行读取字符

方法	说明
public String readLine（）	读取一行数据返回，如果没有数据可读了，会返回null

import java.io.*;

public class Test {
    public static void main(String[] args) throws Exception {
        try (
                Reader fr = new FileReader("src\\com\\abc.txt");
                // 创建一个字符缓冲输入流包装原始的字符输入流
                BufferedReader br = new BufferedReader(fr);
        ) {
                String line; //记住每次读取的一行数据
                while ((line = br.readLine()) != null){
                    System.out.println(line);
                }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

BufferedWriter（字符缓冲输出流）

作用：自带8KB的字符缓冲池，可以提高字符输出流写字符数据的性能。

构造器	说明
public BufferedWriter（Writer r）	把低级的字符输出流包装成一个高级的缓冲字符输出流管道，从而提高字符输出流写数据的性能

字符缓冲输出流新增的功能：换行

方法	说明
public void newLine（）	换行

案例：拷贝出师表到另一个文件，恢复顺序

需求：把《出师表》的文章进行恢复到另一个文件中

import java.io.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

// 目标：恢复出师表的顺序到新文件中去
public class OrderlyCopy {
    public static void main(String[] args) {
        try (
                // 创建缓冲字符输入和输出流管道与源文件连通
                BufferedReader br = new BufferedReader(new FileReader("src\\com\\pt4\\yb.txt"));
                BufferedWriter bw = new BufferedWriter(new FileWriter("src\\com\\pt4\\NorthernExpeditionMemorial.txt"))
        ) {
            // 按照行读取每段，存入到集合中去
            List<String> list = new ArrayList<>();
            String line;
            while ((line = br.readLine()) != null){
                list.add(line);
            }

            // 对List集合的每段文章进行排序
            Collections.sort(list);
            System.out.println(list);

            // 遍历List集合的每段内容，一次写到新文件中去
            for (String s : list) {
                bw.write(s);
                bw.newLine(); // 换行
            }

        }catch (Exception e){
            e.printStackTrace();
        }

    }
}

原始流、缓冲流的性能分析

测试用例：

分别使用原始的字节流，以及字节缓冲流复制一个很大的视频

import java.io.*;

public class Test {
    // 复制的视频路径
    private static final String SRC_FILE = "D:\\resource\\123.avi";
    // 复制到哪个目的地
    private static final String DEST_FILE = "D:\\";

    public static void main(String[] args){
        copy1(); // 低级字节流一个一个字节的赋值，太慢直接淘汰
        copy2(); // 低级字节流按照字节数组赋值，速度较慢
        copy3(); // 缓冲流按照一个一个字节的形式复制，速度较慢
        copy4(); // 缓冲流按照字节数组的形式复制，速度较快，推荐使用
    }

    private static void copy1() {
        long startTime = System.currentTimeMillis();
        try (
                InputStream is = new FileInputStream(SRC_FILE);
                OutputStream os = new FileOutputStream(DEST_FILE + "1.avi");
        ) {
                int b;
                while ((b = is.read()) != -1){
                    os.write(b);
                }
        }catch (Exception e){
            e.printStackTrace();
        }
        long endTTime = System.currentTimeMillis();
        System.out.println("低级字节流一个一个字节复制耗时：" + (endTTime - startTime) /1000.0 + "s");
    }

    private static void copy2() {
        long startTime = System.currentTimeMillis();
        try (
                InputStream is = new FileInputStream(SRC_FILE);
                OutputStream os = new FileOutputStream(DEST_FILE + "2.avi");
        ) {
            byte[] bytes = new byte[1024];
            int len;
            while ((len = is.read(bytes)) != -1){
                os.write(bytes,0,len);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        long endTTime = System.currentTimeMillis();
        System.out.println("低级字节流使用字节数组复制耗时：" + (endTTime - startTime) /1000.0 + "s");
    }

    private static void copy3() {
        long startTime = System.currentTimeMillis();
        try (
                InputStream is = new FileInputStream(SRC_FILE);
                BufferedInputStream bis = new BufferedInputStream(is);
                OutputStream os = new FileOutputStream(DEST_FILE + "3.avi");
                BufferedOutputStream bos = new BufferedOutputStream(os);
        ) {
            int b;
            while ((b = bis.read()) != -1){
                bos.write(b);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        long endTTime = System.currentTimeMillis();
        System.out.println("缓冲流一个一个字节复制耗时：" + (endTTime - startTime) /1000.0 + "s");
    }

    private static void copy4() {
        long startTime = System.currentTimeMillis();
        try (
                InputStream is = new FileInputStream(SRC_FILE);
                BufferedInputStream bis = new BufferedInputStream(is);
                OutputStream os = new FileOutputStream(DEST_FILE + "4.avi");
                BufferedOutputStream bos = new BufferedOutputStream(os);
        ) {
            byte[] bytes = new byte[1024];
            int len;
            while ((len = bis.read(bytes)) != -1){
                bos.write(bytes,0,len);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        long endTTime = System.currentTimeMillis();
        System.out.println("缓冲流使用字节数组复制耗时：" + (endTTime - startTime) /1000.0 + "s");
    }
}