缓冲流

原创

小小小趴菜 2023-09-05 10:10:05 博主文章分类：集合 ©著作权

©著作权归作者所有：来自51CTO博客作者小小小趴菜的原创作品，请联系作者获取转载授权，否则将追究法律责任

缓冲流概述

缓冲流,也叫高效流，是对4个基本的`FileXxx` 流的增强，所以也是4个流，按照数据类型分类通过定义数组的方式确实比以前一次读取一个字节的方式快很多。java开始在设计的时候，它也考虑到了这个问题，就专门提供了带缓冲区的字节类。这种类被称为：缓冲区类(高效类) 写数据：BufferedOutputStream 读数据：BufferedInputStream 构造方法可以指定缓冲区的大小，但是我们一般用不上，因为默认缓冲区大小就足够了。

名称	类
字节缓冲流	`BufferedInputStream` `BufferedOutputStream`
字符缓冲流	`BufferedReader` `BufferedWriter`

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

字节缓冲流

构造方法

方法名	说明
public BufferedInputStream(InputStream in)	创建一个新的缓冲输入流。
public BufferedOutputStream(OutputStream out)	创建一个新的缓冲输出流。

字节缓冲输出流

public class BufferedDemo {
        public static void main(String[] args) throws IOException {

        //相当于把字节流进行了一次装
        //FileOutputStream fos = new FileOutputStream("a.txt");
        //BufferedOutputStream bos = new BufferedOutputStream(fos);

        //简单写法
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("a.txt"));
        //也可以进行追加
        //BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("a.txt",true));

        //写一个字节
        bos.write(97);
        //写一个字节数组
        byte[] by = {97,98,99};
        bos.write(by);
        bos.write("hello".getBytes());

        //指定写一个字节
        bos.write(by,1,2);
        //关闭
        bos.close();
    }
}

字节缓冲输入流

public class BufferedDemo {
    public static void main(String[] args) throws IOException {

        //字节输入缓冲流
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("a.txt"));

        //一次读出一个字节
        int read = bis.read();
        System.out.println((char)read);

        //一次读出一个字节数组
        byte[] by = new byte[1024];
        int len;
        while ((len = bis.read(by)) != -1){
            System.out.println(new String(by,0,len));
        }

    }
}

字节缓冲流复制

public static void main(String[] args) throws IOException {
		//读
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream("a.txt"));
		//写
		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("b.txt"));
		//复制
		byte[] bys = new byte[1024];
		int len =0;
		while((len = bis.read(bys)) != -1){
			bos.write(bys,0,len);
		}
		
		bis.close();
		bos.close();
	}

测试

/*
 * 需求：把D:\\工作\\EV已录视频\\01-课程介绍.mp4复制到当前项目目录下的copy.mp4中
 * 
 * 字节流四种方式复制文件：
 * 基本字节流一次读写一个字节：	共耗时：117235毫秒
 * 基本字节流一次读写一个字节数组： 共耗时：156毫秒
 * 高效字节流一次读写一个字节： 共耗时：1141毫秒
 * 高效字节流一次读写一个字节数组： 共耗时：47毫秒
 */
public class CopyMp4Demo {
	public static void main(String[] args) throws IOException {

		long start = System.currentTimeMillis();

		 method1("D:\\工作\01-vedio.mp4", "copy1.mp4");
		 method2("D:\\工作\01-vedio.mp4", "copy2.mp4");
		 method3("D:\\工作\01-vedio.mp4", "copy3.mp4");
		 method4("D:\\工作\01-vedio.mp4", "copy4.mp4");	
	
		long end = System.currentTimeMillis();
		System.out.println("共耗时：" + (end - start) + "毫秒");
	}

	// 高效字节流一次读写一个【字节数组】：
	public static void method4(String srcString, String destString)
			throws IOException {
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
				srcString));
		BufferedOutputStream bos = new BufferedOutputStream(
				new FileOutputStream(destString));

		byte[] bys = new byte[1024];
		int len = 0;
		while ((len = bis.read(bys)) != -1) {
			bos.write(bys, 0, len);
		}

		bos.close();
		bis.close();
	}

	// 高效字节流一次读写一个【字节】：
	public static void method3(String srcString, String destString)
			throws IOException {
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
				srcString));
		BufferedOutputStream bos = new BufferedOutputStream(
				new FileOutputStream(destString));

		int by = 0;
		while ((by = bis.read()) != -1) {
			bos.write(by);

		}

		bos.close();
		bis.close();
	}

	// 基本字节流一次读写一个字节数组
	public static void method2(String srcString, String destString)
			throws IOException {
		FileInputStream fis = new FileInputStream(srcString);
		FileOutputStream fos = new FileOutputStream(destString);

		byte[] bys = new byte[1024];
		int len = 0;
		while ((len = fis.read(bys)) != -1) {
			fos.write(bys, 0, len);
		}

		fos.close();
		fis.close();
	}

	// 基本字节流一次读写一个字节
	public static void method1(String srcString, String destString)
			throws IOException {
		FileInputStream fis = new FileInputStream(srcString);
		FileOutputStream fos = new FileOutputStream(destString);

		int by = 0;
		while ((by = fis.read()) != -1) {
			fos.write(by);
		}

		fos.close();
		fis.close();
	}
}

字符缓冲流

构造方法

方法名	说明
public BufferedReader(Reader in)	创建一个新的缓冲输入流。
public BufferedWriter(Writer out)	创建一个新的缓冲输出流。

字符缓冲输出流

public static void main(String[] args) throws IOException {

        //字符输出流
        BufferedWriter bw = new BufferedWriter(new FileWriter("c.txt"));

        bw.write(97);
        bw.write("hello");
        char[] chs = {'j','a','v','a',};
        bw.write(chs);
        bw.close();
    }

字符缓冲输入流

public static void main(String[] args) throws IOException {

        //字符输入流
        BufferedReader br = new BufferedReader(new FileReader("c.txt"));

        //读一个字节
        int read = br.read();
        System.out.println(read);

        //循环读
        int ch;
        while ( (ch = br.read()) != -1){
            System.out.print((char)ch);
        }

        //循环读字符数组
        char[] c = new char[1024];
        int ch2;
        while ( (ch2 = br.read(c)) != -1){
            System.out.print(new String(c,0,ch2));
        }

    }

字符流缓冲流复制

/*
 * 需求：把a.txt内容复制到当前项目目录下的b.txt中
 * 
 * 数据源：
 * 		a.txt -- 读取数据 -- 字符转换流 -- InputStreamReader -- FileReader -- BufferedReader
 * 目的地：
 * 		b.txt -- 写出数据 -- 字符转换流 -- OutputStreamWriter -- FileWriter -- BufferedWriter
 */
public class CopyFileDemo {
	public static void main(String[] args) throws IOException {
		// 封装数据源 读
		BufferedReader br = new BufferedReader(new FileReader("a.txt"));
		// 封装目的地 写
		BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));

		// 两种方式其中的一种一次读写一个字符数组
		char[] chs = new char[1024];
		int len = 0;
		while ((len = br.read(chs)) != -1) {
			bw.write(chs, 0, len);
			bw.flush();
		}

		// 释放资源
		bw.close();
		br.close();
	}
}

字符缓冲流特有方法

类名	方法名	说明
BufferedReader	public String readLine()	一次读取一行文字
BufferedWriter	public void newLine()	写一行行分隔符,由系统属性定义符号

/*
 * 字符缓冲流的特殊方法：
 * BufferedWriter:
 *        public void newLine():根据系统来决定换行符  写入时换行
 */
public static void main(String[] args) throws IOException {

    // 创建字符缓冲输出流对象
    BufferedWriter bw = new BufferedWriter(new FileWriter("a.txt"));

    for (int x = 0; x < 10; x++) {
        bw.write("hello" + x);
        // bw.write("\r\n");//之前换行做法
        bw.newLine();//现在换行做法
        bw.flush();
    }

    bw.close();
}

/*
 * 字符缓冲流的特殊方法：
 * BufferedReader:
 *        public String readLine()：一次读取一行数据
 *        包含该行内容的字符串，不包含任何行终止符(不包含换行)，如果已到达流末尾，则返回 null
 */
public static void main(String[] args) throws IOException {
    // 创建字符缓冲输入流对象
    BufferedReader br = new BufferedReader(new FileReader("bw2.txt"));

    // String line = br.readLine();//一次读取一行数据
    // System.out.println(line);

    // 最终版代码
    String line = null;
    while ((line = br.readLine()) != null) {
        System.out.println(line);
    }

    //释放资源
    br.close();
}