好記性不如賴筆頭……

/**
* @author Ckinghan
* @描述：使用位元組流複製檔案與使用高速緩衝流複製檔案的對比示例
* WebLogin.log 檔案大小：15,028,378 位元組（14.3M）
*/

package com.Ckinghan.outputStream;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import
 
 java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

/**
 * @author Ckinghan
 *  @描述：使用位元組流複製檔案與使用高速緩衝流複製檔案的對比示例
 *  WebLogin.log 檔案大小：15,028,378 位元組（14.3M）
 */
public class InputStreamCopyCompared {

    public static void main(String[] args) {
        long
 
 startTime = System.currentTimeMillis();
        //位元組流複製檔案，複製方式：一次讀取一個字元
        stringFileCopy();
        long endTime = System.currentTimeMillis();
        System.out.println("位元組流複製檔案，複製方式：一次讀取一個字元耗時："+(endTime-startTime)+"毫秒複製成功");

        startTime = System.currentTimeMillis();
        //使用高效緩衝區的位元組流讀取複製檔案，複製方式：一次複製一個字元
 

        bufferedInputStreamReader();
        endTime = System.currentTimeMillis();
        System.out.println("使用高效緩衝區的位元組流讀取複製檔案，複製方式：一次複製一個字元耗時："+(endTime-startTime)+"毫秒複製成功");

        startTime = System.currentTimeMillis();
        //用高效緩衝區的位元組流讀取複製檔案，複製方式：一次複製指定數量的位元組
        FileCopy();
        endTime = System.currentTimeMillis();
        System.out.println("位元組流複製檔案，複製方式：一次複製指定數量的位元組耗時："+(endTime-startTime)+"毫秒複製成功");

        startTime = System.currentTimeMillis();
        //用高效緩衝區的位元組流讀取複製檔案，複製方式：一次複製指定數量的位元組
        bufferedInputStreamCopyFile();
        endTime = System.currentTimeMillis();
        System.out.println("用高效緩衝區的位元組流讀取複製檔案，複製方式：一次複製指定數量的位元組耗時："+(endTime-startTime)+"毫秒複製成功");
    }

    /**
     * @描述：位元組流複製檔案，複製方式：一次讀取一個字元
     * @建立時間：
     */
    public static void stringFileCopy(){
        //建立位元組的輸出、輸出流
        InputStream inputStream = null;
        OutputStream outputStream = null;
        try {
            //例項化位元組輸入、輸出流
            inputStream = new FileInputStream("E:/WebLogin.log");
            outputStream = new FileOutputStream("E:/new3.log");
            //建立讀取的位元組ACSII碼
            int len = -1;
            //迴圈讀取檔案資料
            while ((len = inputStream.read()) != -1) {
                //寫入檔案
                outputStream.write(len);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //如果輸出、輸入位元組流有建立，則關閉，注意關閉順序，先關輸出流再關輸入流
            try {
                if(outputStream != null)
                    outputStream.close();
                if(inputStream != null)
                    inputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

    /**
     * @描述：位元組流複製檔案，複製方式：一次複製指定數量的位元組
     * @建立時間：
     */
    public static void FileCopy(){
        //建立流物件
        InputStream inputStream = null;
        OutputStream stream = null;

        try {
            //例項化流物件
            inputStream = new FileInputStream("E:/WebLogin.log");
            stream = new FileOutputStream("E:/new2.log");
            //接收讀取的位元組長度
            int len = -1;
            //接收讀取的位元組
            byte[] bs = new byte[1024];
            //迴圈讀取位元組
            while((len = inputStream.read(bs)) != -1){
                //將讀取的位元組寫入到檔案中
                stream.write(bs, 0, len);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                //關閉輸出流
                if(stream != null)
                    stream.close();
                //關閉輸入流
                if(inputStream != null)
                    inputStream.close();
            } catch (IOException e2) {
                e2.printStackTrace();
            }
        }

    }

    /**
     * @描述：用高效緩衝區的位元組流讀取複製檔案，複製方式：一次複製指定數量的位元組
     * @建立時間：
     */
    public static void bufferedInputStreamCopyFile(){
        //建立位元組流物件
        InputStream inputStream = null;
        OutputStream outputStream = null;

        try {
            //例項化高效緩衝區位元組流的輸入、輸出物件
            inputStream = new BufferedInputStream(new FileInputStream("E:/WebLogin.log"));
            outputStream = new BufferedOutputStream(new FileOutputStream("E:/new.log"));
            //每次讀取的檔案位元組數量
            int len = -1;
            //每次讀取的檔案位元組資料
            byte[] bs = new byte[1024];
            //迴圈讀取檔案，直至讀到檔案末尾
            while ((len = inputStream.read(bs)) != -1) {
                //寫入到檔案
                outputStream.write(bs, 0, len);
            }
            //清空緩衝區，將寫入到檔案中的資料儲存
            outputStream.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                //關閉流
                if(outputStream != null)
                    outputStream.close();
                if(inputStream != null)
                    inputStream.close();
            } catch (IOException e2) {
                e2.printStackTrace();
            }
        }
    }

    /**
     * @描述：使用高效緩衝區的位元組流讀取複製檔案，複製方式：一次複製一個字元
     * @建立時間：
     */
    public static void bufferedInputStreamReader(){
        //建立位元組流物件
        InputStream inputStream = null;
        OutputStream outputStream = null;

        try {
            //例項化高效緩衝區位元組流的輸入、輸出物件
            inputStream = new BufferedInputStream(new FileInputStream("E:/WebLogin.log"));
            outputStream = new BufferedOutputStream(new FileOutputStream("E:/login.log"));

            //讀取的位元組ACSII碼
            int val = -1;

            //迴圈讀取檔案，直至讀到檔案末尾
            while((val = inputStream.read()) != -1){
                //寫入到檔案
                outputStream.write(val);
            }
            //清空緩衝區，將寫入到檔案中的資料儲存
            outputStream.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                //關閉流
                if(outputStream != null)
                    outputStream.close();
                if(inputStream != null)
                    inputStream.close();
            } catch (IOException e2) {
                e2.printStackTrace();
            }
        }

    }

}

執行結果：

位元組流複製檔案，複製方式：一次讀取一個字元耗時：38814毫秒複製成功
使用高效緩衝區的位元組流讀取複製檔案，複製方式：一次複製一個字元耗時：146毫秒複製成功
位元組流複製檔案，複製方式：一次複製指定數量的位元組耗時：72毫秒複製成功
用高效緩衝區的位元組流讀取複製檔案，複製方式：一次複製指定數量的位元組耗時：37毫秒複製成功

可以看出，使用了高速緩衝流複製檔案，所用時間比之未使用之前的相對較少，而且檔案越大，差距越大。