原理：在建立流物件時，在記憶體中會建立一個預設大小的緩衝陣列，在讀寫時，先將資料寫在緩衝陣列中，再將緩衝陣列交給系統-JVM，減少了系統讀寫次數，從而提高了讀寫效率
這跟用陣列進行read（byte[] b）和write(byte[] b)差不多

BufferedOutputStream類 extends OutputStream-----位元組緩衝輸出流
構造方法：
public BufferedOutputStream(OutputStream out) ---緩衝陣列預設為8192
public BufferedOutputStream(OutputStream out, int size) ---size設定緩衝陣列的大小

package iotest.bufferedIOtest;

 
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class BufferedOutputStreamTest01 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("src\\iotest\\bufferedIOtest\\a.txt");
        BufferedOutputStream bos 
 
= new BufferedOutputStream(fos);
        bos.write(97);
        bos.flush();
        fos.close();
        bos.close();
    }
}

BufferedInputStream 類extends InputStream ---位元組緩衝輸入流
構造方法：
public BufferedInputStream(InputStream in)---緩衝陣列預設為8192
public BufferedInputStream(InputStream in, int size) --size設定緩衝陣列的大小

使用步驟：
1.建立一個繼承了InputStream 的類的物件，構造方法中繫結要讀取的檔案的地址
2.建立BufferedInputStream 物件，構造方法中傳遞繼承了InputStream 的類的物件
3.使用BufferedInputStream 物件的read方法，讀資料
4.釋放資源（直接關閉BufferedOutputStream，OutputStream會自動關閉）

package iotest.bufferedIOtest;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class BufferedInputStreamTest01 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("src\\iotest\\bufferedIOtest\\a.txt");
        BufferedInputStream bis = new BufferedInputStream(fis);
        //一次讀取一個位元組
        /*int len = 0;
        while ((len = bis.read()) != -1){
            System.out.print((char)len);
        }*/

        //運用陣列，一次讀取多個位元組
        int len = 0;
        byte[] bytes = new byte[1024];
        while ((len = bis.read(bytes)) != -1){
            System.out.println(new String(bytes));
        }
        bis.close();
    }
}

不同方式複製檔案的效率比較

package iotest.bufferedIOtest.copytest;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

//運用位元組流，一次讀取一個位元組，來複制檔案
//檔案複製共用了429毫秒
public class Copy1 {
    public static void main(String[] args) throws IOException {
        long startTime = System.currentTimeMillis();
        FileInputStream fis = new FileInputStream("C:\\test\\1.jpg");
        FileOutputStream fos = new FileOutputStream("D:\\test\\1.jpg");

        int len = 0;
        while ((len = fis.read()) != -1){
            fos.write(len);
        }
        fos.close();
        fis.close();
        long endTime = System.currentTimeMillis();
        System.out.println("檔案複製共用了"+(endTime-startTime)+"毫秒");
    }
}

package iotest.bufferedIOtest.copytest;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

//運用位元組流，運用位元組陣列來讀取檔案
//檔案複製共用了11毫秒
public class Copy2 {
    public static void main(String[] args) throws IOException {
        long startTime = System.currentTimeMillis();
        FileInputStream fis = new FileInputStream("C:\\test\\1.jpg");
        FileOutputStream fos = new FileOutputStream("D:\\test\\1.jpg");

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

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

        long endTime = System.currentTimeMillis();
        System.out.println("檔案複製共用了"+(endTime-startTime)+"毫秒");
    }
}

package iotest.bufferedIOtest.copytest;

import java.io.*;

//運用位元組緩衝流，一次讀寫一個位元組，來複制檔案
//檔案複製共用了14毫秒
public class Copy3 {
    public static void main(String[] args) throws IOException {
        long startTime = System.currentTimeMillis();

        FileInputStream fis = new FileInputStream("C:\\test\\1.jpg");
        FileOutputStream fos = new FileOutputStream("D:\\test\\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();

        long endTime = System.currentTimeMillis();
        System.out.println("檔案複製共用了"+(endTime-startTime)+"毫秒");


    }
}

package iotest.bufferedIOtest.copytest;

import java.io.*;

//運用位元組緩衝流，運用位元組陣列，來複制檔案
//檔案複製共用了10毫秒
public class Copy4 {
    public static void main(String[] args) throws IOException {
        long startTime = System.currentTimeMillis();

        FileInputStream fis = new FileInputStream("C:\\test\\1.jpg");
        FileOutputStream fos = new FileOutputStream("D:\\test\\1.jpg");

        BufferedInputStream bis = new BufferedInputStream(fis);
        BufferedOutputStream bos = new BufferedOutputStream(fos);

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

        long endTime = System.currentTimeMillis();
        System.out.println("檔案複製共用了"+(endTime-startTime)+"毫秒");



    }
}

結論：陣列+緩衝流 > 只用陣列 > 只用緩衝流，來一個位元組一個位元組的讀寫 > 一個位元組一個位元組的讀寫