2（1）-字节缓冲流

package com.io;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

import org.junit.Test;
/**
 * 
 * @author Administrator
 *1、流的分类
 *（1）按照数据流向的不同，分为输入流和输出流
 *（2）按照处理数据单位的不同，分为字节流和字符流
 *（3）按照角色的不同，分为节点流（直接作用于文件，所有带File的InputStream OutputStream）、处理流（作用于节点流上面，提高效率）
 *2、IO体系
 *抽象基类                    节点流（即文件流）            缓总流（处理流的一种）
 *InputStream   FileInputStream         BufferedInputStream
 *OutputStream  FileOutputStream         BufferedOutputStream(flush)
 *Reader        FileReader                BufferedReader(readLine方法，一次读一行)
 *Writer        FileWriter                BufferedWriter(flush)
 *3、所有的处理流都作用于上面四种节点流，才能进行对文件操作
 */
public class 缓冲字节流 {
    
    
    @Test
    public void compareBuffered(){
        
        long begin = System.currentTimeMillis();
        copyFileBuffered();
        long end = System.currentTimeMillis();
        System.out.println("加了缓冲流的复制时间：" + (end-begin));
        
        begin = System.currentTimeMillis();
        copyFileNoteBuffered();
        end = System.currentTimeMillis();
        System.out.println("没有缓冲流的复制时间：" + (end-begin));
    }
    
    /**
     * 加了缓冲流的文件复制
     */
    @Test
    public void copyFileBuffered(){
        //3、创建处理流（缓冲流）
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            //1、创建文件对象
            File inFile = new File("v1.mp4");
            File outFile = new File("v2.mp4");
            //2、创建对应的节点流
            FileInputStream fis = null;
            FileOutputStream fos = null;
         
            //4、实例化节点流和处理流
            fis = new FileInputStream(inFile);
            fos = new FileOutputStream(outFile);
            bis = new BufferedInputStream(fis);
            bos = new BufferedOutputStream(fos);
            //5、定义字节数组
            byte[] b = new byte[1024];
            int len;
            //6、开始读写文件
            while((len = bis.read(b)) != -1){
                bos.write(b, 0, len);
                bos.flush();//刷新一下，重要
            }
        }  catch (IOException e) {
            e.printStackTrace();
        }finally{
            //在关闭最外层的处理流的时候会自动关闭里面的节点流，所以节点流不需要显示的关闭
            try {
                bis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            
            try {
                bos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    
    /**
     * 没有缓冲流的文件复制
     */
    @Test
    public void copyFileNoteBuffered(){
        //2、创建对应的节点流
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            //1、创建文件对象
            File inFile = new File("v1.mp4");
            File outFile = new File("v3.mp4");
            fis = null;
            fos = null;
 
            //4、实例化节点流和处理流
            fis = new FileInputStream(inFile);
            fos = new FileOutputStream(outFile);
            
            byte[] b = new byte[1024];
            int len;
            //6、开始读写文件
            while((len = fis.read(b)) != -1){
                fos.write(b, 0, len);
            }
        }  catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            
            try {
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}