缓冲流

文件字节流（FileInputStream、FileOutputStream）和文件字符流（FileReader、FileWriter）这些都是计算机与硬盘之间发生的I/O操作，基于硬盘的读写相对比较慢，读写操作收到了硬盘读取速度的限制。为了能够提高读写速度，一定程度上绕过硬盘的限制，Java提供了一种缓冲流来实现。

缓冲字节流（BufferedInputStream、BufferedOutputStream）和缓冲字符流（BufferedReader、BufferedWriter）就是先把数据缓冲在内存里，在内存中去做IO操作。基于内存的IO操作比基于硬盘的IO操作快很多。

 

import java.io.*;

//关闭流的时候，本着先来后走的原则
public class Test11 {
    public static void main(String[] args) {
        try {
            //testBufferedStream();
            //testBufferedOutputStream();
            Test11.copyFile();
        } catch (Exception e) {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        }
    }
    
    public static void testBufferedInputStream() throws Exception {
        //文件字节输入流对象
        FileInputStream in = new FileInputStream("E:\\1.txt");
        
        //缓冲字节输入流对象(参数为FileInputStream的类型或其子类)
        BufferedInputStream bufferin = new BufferedInputStream(in);
        
        byte[] b = new byte[100];
        
        int len = 0;    //    测算读取时，有没有到最后一位
        while((len = bufferin.read(b)) != -1) {
            System.out.println(new String(b, 0, len));
        }
        bufferin.close();
        in.close();
    }
    
    public static void testBufferedOutputStream() throws Exception {
        //文件字节输出流
        FileOutputStream ou = new FileOutputStream("E:\\2.txt");
        
        //把字节数出流对象放到缓冲字节流
        BufferedOutputStream bufferout = new BufferedOutputStream(ou);
        
        String str = "Hello World, Wish you good offer!";
        
        bufferout.write(str.getBytes()); //写入内存中
        
        bufferout.flush();    //刷到硬盘上
        bufferout.close();
        ou.close();
    }
    
    //用缓冲流实现文件的复制
    
    public static void copyFile() throws Exception {
        //缓冲输入流
        BufferedInputStream br_in = new BufferedInputStream(new FileInputStream("E:\\\\2.txt"));
        
        //缓冲输出流
        BufferedOutputStream br_out = new BufferedOutputStream(new FileOutputStream("E:\\\\3.txt"));
        
        byte[] b = new byte[1024];
        
        int len = 0;
        
        //读到文件的最后一个字符的后面，这个时候返回值就是-1
        while((len = br_in.read(b)) != -1) {
             br_out.write(b, 0, len);//写到内存
        }
        
        br_out.flush();
        
        br_out.close();
        br_in.close();    
    }
    
}

 

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class Test12 {
    public static void main(String[] args) throws Exception {
        //testBufferedReader();
        //testBufferedWriter();
        copyFile();
    }
    
    /*缓冲字符流
     * 
     */
    public static void testBufferedReader() throws Exception {
        FileReader fr = new FileReader("E:\\2.txt");
        
        BufferedReader br = new BufferedReader(fr);
        
        char[] c = new char[1000];
        int len = 0;
        
        //读到文件的最后一个字符的下一位，返回值是-1
        while((len = br.read(c)) != -1) {
            System.out.println(new String(c, 0, len));
        }
        
        br.close();
        fr.close();
    }
    
    /*缓冲字符输出流
     * */
    public static void testBufferedWriter() throws Exception {
        FileWriter fw = new FileWriter("E:\\3.txt");
            
        BufferedWriter bw = new BufferedWriter(fw);
        
        String str = "Wish you get married!";
        
        bw.write(str);
        bw.flush();
        
        bw.close();
        fw.close();
    }
    
    /*copyFile
     * */
    public static void copyFile() throws Exception {
        BufferedReader br =  new BufferedReader(new FileReader("E:\\3.txt"));        
        BufferedWriter bw = new BufferedWriter(new FileWriter("E:\\4.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();
        
    }
}