【java学习—十三】处理流之一：缓冲流（1）

---

0. 引言

上一章节讲了：文件字符流和字节流（基于硬盘）
其中，用到的方法有：FlieInuputStream、FileOutputStream、FileReader、FileWriter，这些都是计算机与硬盘之间发生的io操作。

    基于硬盘的读写相对是比较慢的，这个操作的速度受到硬盘的读写速度制约，为了能够提高读写速度，一定程度上绕过硬盘的限制，java提供一种缓冲流（基于内存）来实现。
对应关系如下：

字符流&字节流	提高读写速度	缓冲流
FlieInuputStream	→	BufferedInputStream
FileOutputStream	→	BufferedOutputStream
FileReader	→	BufferedReader
FileWriter	→	BufferedWriter

1. 缓冲流

    为了提高数据读写的速度， Java API 提供了带缓冲功能的流类，在使用这些流类时，会创建一个内部缓冲区数组。

根据数据操作单位可以把缓冲流分为：

    ufferedInputStream 和 BufferedOutputStream；
    BufferedReader 和 BufferedWriter

    缓冲流要“套接”在相应的节点流之上，对读写的数据提供了缓冲的功能，提高了读写的效率，同时增加了一些新的方法。
对于输出的缓冲流，写出的数据会先在内存中缓存，使用 flush() 将会使内存中的数据立刻写出。

缓冲流就是先把数据缓冲到内存里，在内存中去做io操作；
基于内存的io操作大概能比基于硬盘的io操作快75000多倍。

2. 缓冲字节流

    ufferedInputStream 和 BufferedOutputStream；

2.1. 缓冲字节输入流

举例：
    将D:/java_doc/eclipse-workspace/demo/src/day13/tt.txt 的内容输入到控制台，其中tt.txt的内容为：“这个是tt.txt文件里的内容”

package day13;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;

public class Test {
	public static void main(String[] args) {
		try {
			Test.testBufferedInputStream();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	
	/**
	 * 缓冲字节输入流
	 * BufferedInputStream
	 * @throws Exception 
	 */
	public static void testBufferedInputStream() throws Exception {
		//文件字节输入流对象
		FileInputStream in = new FileInputStream("D:\\java_doc\\eclipse-workspace\\demo\\src\\day13\\tt.txt"); 
		
		//把文件字节输入流 放到 缓冲字节输入流对象
		BufferedInputStream br = new BufferedInputStream(in);
		
		byte[] b = new byte[100];
		
		int len = 0;
		
		while((len = br.read(b)) != -1) {
			System.out.println(new String(b, 0, len));
		}
		
		//关闭流的时候，本着一个最晚开的最早关，依次关
		br.close();
		in.close();
		
	}
	
}

运行结果：

2.2. 缓冲字节输出流

举例：
    将“hello world”字符串输出到D:/java_doc/eclipse-workspace/demo/src/day13/tt1.txt 中

package day13;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;

public class Test {
	public static void main(String[] args) {
		try {
			Test.testBufferedOutputStream();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	
	
	/**
	 * 缓冲字节输出流
	 * BufferedOutputStream
	 */
	public static void testBufferedOutputStream() throws Exception {
		//创建字节输出流对象
		FileOutputStream out = new FileOutputStream ("D:\\java_doc\\eclipse-workspace\\demo\\src\\day13\\tt1.txt");
		
		//把字节输出流对象放到缓冲字节输出流中
		BufferedOutputStream bo = new BufferedOutputStream(out);
		
		String s = "hello world";
		
		bo.write(s.getBytes());//写到内存中
		
		bo.flush();//刷到硬盘上
		
		bo.close();
		out.close();
	}
	
	
}

运行结果：（程序会创建tt1.txt文件，打开tt1.txt文件会看到里面的内容）

2.3. 缓冲流实现文件的复制

举例：
    将D:/java_doc/eclipse-workspace/demo/src/day13/tt1.txt 的内容复制到 D:/java_doc/eclipse-workspace/demo/src/day13/tt2.txt 中。其中，tt1.txt文件的内容为：“hello world”。

package day13;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;

public class Test {
	public static void main(String[] args) {
		try {
			Test.copyFile();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	
	/**
	 * 缓冲流实现文件的复制
	 */
	public static void copyFile() throws Exception {
		//缓冲输入流
		BufferedInputStream br = new BufferedInputStream(new FileInputStream("D:\\java_doc\\eclipse-workspace\\demo\\src\\day13\\tt1.txt"));
		
		//缓冲输出流
		BufferedOutputStream bo = new BufferedOutputStream(new FileOutputStream("D:\\java_doc\\eclipse-workspace\\demo\\src\\day13\\tt2.txt"));
		
		byte[] b = new byte[1024];
		
		int len = 0;//设置一个每次读取到的数据长度，直到br.read方法执行到最后（比如说，文件中只有“hello world”，执行到最后一个就是读取到d的后面。这个时候返回值就是-1）
		
		while((len = br.read(b)) != -1) {
			bo.write(b, 0, len);//写到内存
		}
		
		bo.flush();//刷到硬盘
		
		bo.close();
		br.close();	
	}
	
}

运行结果：（程序会创建tt2.txt文件，将 tt1.txt 的内容复制到 tt2.txt 中）

3. 缓冲字符流

    BufferedReader 和 BufferedWriter；

举例：

与上面代码流程一样，只是换了字符流相关的函数，下面将三种例子写在了一起。

package day13;
 
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
 
/**
 * 缓冲字符流
 * @author lby
 *
 */
public class Test1 {
    public static void main(String[] args) {
        try {
//          Test1.testBufferedReader();
//          Test1.testBufferedWriter();
            Test1.copyFile();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
     
    /**
     * 缓冲字符输入流
     * BufferedReader
     */
    public static void testBufferedReader() throws Exception{
        FileReader r = new FileReader("D:\\testdemo\\demo\\src\\day13\\tt.txt");
         
        BufferedReader br = new BufferedReader(r);
         
        char[] c = new char[100];
         
        int len = 0;
         
        while((len = br.read(c)) != -1){//br.read(c)读到文件的最后一个字符的下一位，返回值就是-1
            System.out.println(new String(c, 0, len));
        }
        br.close();
        r.close();
    }
     
    /**
     * 缓冲字符输出流
     * BufferedWriter
     */
    public static void testBufferedWriter() throws Exception{
        FileWriter fw = new FileWriter("D:\\testdemo\\demo\\src\\day13\\tt3.txt");
         
        BufferedWriter bw = new BufferedWriter(fw);
         
        String s = "hello world!!!!";
         
        bw.write(s);
         
        bw.flush();
         
        bw.close();
        fw.close();
    }
     
    /**
     * 缓冲字符流复制文件
     */
    public static void copyFile() throws Exception{
        BufferedReader br = new BufferedReader(new FileReader("D:\\testdemo\\demo\\src\\day13\\tt3.txt"));
         
        BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\testdemo\\demo\\src\\day13\\tt4.txt"));
         
        char[] c = new char[100];
         
        int len = 0;
         
        while((len = br.read(c)) != -1){
            bw.write(c, 0, len);
        }
         
        bw.flush();
         
        bw.close();
        br.close();
    }
}

注意：缓冲流是把数据缓冲到内存中