缓冲流（两类四种）

一、缓冲字节流

1、缓冲字节输出流（BufferedOutputStream）

public static void main(String[] args) throws IOException {
        /*
        字节缓冲输出流使用步骤：
            1：创建FileOutputStream对象，指定输出文件
            2：创建BufferedOutputStream对象，对FileOutputStream进行“包装”，使其效率提高
            3：使用BufferedOutputStream对象调用write方法，将数据写入内部缓冲区中
            4：使用BufferedOutputStream对象调用flush方法，将内部缓冲区的数据刷新到文件中
            5：释放资源（若释放资源，第4步flush可省略，因为在调用close时会先进行flush再释放资源）
        */
        FileOutputStream fos = new FileOutputStream("b.txt");
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        bos.write("字节缓冲输出流".getBytes());
        bos.flush();
        bos.close();
//        fos.close();// 不用手动释放，缓冲流释放资源时自动将其内部的字节流进行关闭
    }

2、缓冲字节输入流（BufferedInputStream）

public static void main(String[] args) throws IOException {
        /*
        字节缓冲输出流使用步骤：
            1：创建FileInputStream对象，指定输出文件
            2：创建BufferedInputStream对象，对FileInputStream进行“包装”，使其效率提高
            3：使用BufferedInputStream对象调用read方法，将数据读入内部缓冲区中
            4：释放资源
        */

        //方式一：
       /*
       FileInputStream fis = new FileInputStream("b.txt");
        BufferedInputStream bis = new BufferedInputStream(fis);
        int len=0;
        while((len=bis.read())!=-1){
            System.out.println(len);
        }
        bis.close();
        */

        //方式二：
        FileInputStream fis = new FileInputStream("b.txt");
        BufferedInputStream bis = new BufferedInputStream(fis);
        int len = 0;
        byte[] bytes = new byte[1024];
        while ((len = bis.read(bytes)) != -1) {
            System.out.println(new String(bytes, 0, len));
        }
        bis.close();
    }

3、测试缓冲流与字符流复制文件的速度

package demo09.buffer;

import java.io.*;
import java.util.Arrays;

public class demo07copy02 {
    public static void main(String[] args) throws IOException {
        copy01();
        copy02();
    }

    private static void copy02() throws IOException {
        long start = System.currentTimeMillis();
        FileInputStream fis = new FileInputStream("c:\\1.jpg");
        FileOutputStream fos = new FileOutputStream("d:\\1.jpg");
        int len = 0;
        while ((len = fis.read()) != -1) {
            fos.write(len);
        }
        fos.close();
        fis.close();
        System.out.println("使用字节流花费时间："+(System.currentTimeMillis()-start));
    }

    private static void copy01() throws IOException {
        long start = System.currentTimeMillis();
        FileInputStream fis = new FileInputStream("c:\\1.jpg");
        FileOutputStream fos = new FileOutputStream("d:\\1.jpg");
        BufferedInputStream bis = new BufferedInputStream(fis);
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        int len = 0;
        while ((len = bis.read()) != -1) {
            bos.write(len);
        }
        bos.close();
        bis.close();
        System.out.println("使用缓冲流花费时间："+(System.currentTimeMillis()-start));
    }
}

经测试：使用缓冲流比字节流速度要快的多。
注：如果在测试代码中都添加byte数组，则测试效果不明显。

二、缓冲字符流

1、字符缓冲输出流（BufferedWriter）

public static void main(String[] args) throws IOException {
        /*
        字符缓冲输出流使用步骤：
            1：创建FileWrite对象，指定输出文件
            2：创建BufferedWrite对象，对FileWrite进行“包装”，使其效率提高
            3：使用BufferedWrite对象调用write方法，将数据写入内部缓冲区中
            4：使用BufferedWrite对象调用flush方法，将内部缓冲区的数据刷新到文件中
            5：释放资源（若释放资源，第4步flush可省略，因为在调用close时会先进行flush再释放资源）
        */
        BufferedWriter bw = new BufferedWriter(new FileWriter("c.txt"));
        for (int i = 0; i < 10; i++) {
            bw.write("相信美好的事情即将发生...");
            bw.newLine();
        }
        bw.flush();
        bw.close();
    }

2、字符缓冲输入流（BufferedReader）

public static void main(String[] args) throws IOException {
        /*
        字符缓冲输入流使用步骤：
            1：创建FileReader对象，指定输出文件
            2：创建BufferedReader对象，对FileReader进行“包装”，使其效率提高
            3：使用BufferedReader对象调用read/readLine方法，将数据读入内部缓冲区中
            4：释放资源
        */

        // 方式一
        /*
        BufferedReader br = new BufferedReader(new FileReader("c.txt"));
        String s = "";
        while ((s = br.readLine()) != null) {
            System.out.println(s);
        }
        br.close();
        */

        // 方式二
        BufferedReader br = new BufferedReader(new FileReader("c.txt"));
        int len = 0;
        while ((len = br.read()) != -1) {
            System.out.print((char) len);
        }
        br.close();
    }