BufferedInputStream和BufferedOutputStream是带缓冲区的字节输入输出处理流。它们本身并不具有IO流的读取与写入功能，只是在别的流(节点流或其他处理流)上加上缓冲功能提高效率，就像是把别的流包装起来一样，因此缓冲流是一种处理流。事实上，这两个处理流（BufferedInputStream和 BufferedOutputStream），加上BufferedReader和BufferedWriter，这四个流在设计时使用到的正是装饰设计模式，通过装饰设计模式，得以在其他的流的基础上增加缓冲的功能！

import java.io.IOException;
import java.io.OutputStream;

public class MyBos {
    
    private byte[] buf; //缓冲字节数组
    private int count;  //记录目前缓冲数组中的有效字节数
    private OutputStream os;//被装饰的底层输出字节流
    
    
    //构造方法
    public MyBos(OutputStream os) throws Exception {
        this(os, 8192);     //若不显式指定缓冲数组的大小，则默认分配8k空间
    }
    
    public MyBos(OutputStream os, int size) throws Exception {
        if(size ) {
            throw new Exception("缓冲区空间大小分配错误：" + size);
        }
        this.os = os;
        buf = new byte[size];
    }
    
    /**
     * 写出单个字节数据
     * @param b 写出的字节数据
     * @throws IOException
     */
    public void write(int b) throws IOException {
        if(count == buf.length) {//若count == buf.length，说明缓冲区buf已满，则先将缓冲区数据写出
            os.write(buf);      //调用os的wirte(byte[] buf)方法讲数据写出！
            count = 0;          //重置count
        }
        
        buf[count++] = (byte)b;     //将字节数据写入缓冲区，写入到count所在索引位置上
    }
    
    /**
     * 将字节数组b[offset, offset+len)部分写出
     * @param b     字节数组
     * @param offset    开始位置
     * @param len       长度
     * @throws Exception 
     */
    public void write(byte[] b, int offset, int len) throws Exception {
        
        if(offset  len)) {
            throw new Exception("数组索引越界异常！");
        }
        
        if(len > buf.length) {  //若写出的字节数组b数据大于缓冲数组
            flush();            //则先调用flush()方法将缓冲数组的数据写出
            os.write(b, offset, len);   //直接将数组b的数据通过os的wirte方法写出，不写入缓冲数组了
            return;
        }
        
        if(len > buf.length - count) {  //若缓冲数组剩余空间不足len长度
            flush();                    //则先将缓冲数组的数据写出
        }
        
        System.arraycopy(b, offset, buf, count, len);
        count += len;
        
    }
    
    /**
     * 刷新缓冲区
     * @throws IOException
     */
    public void flush() throws IOException {
        if(count > 0) { //若缓冲区中有数据，则调用底层输出流os将数据写出
            os.write(buf, 0, count);
            os.flush();
            count = 0;  //重置count
        }
    }

    /**
     * 关闭流
     * @throws IOException
     */
    public void close() throws IOException {
        if(null != os) {
            flush();    //先将缓冲数组的数据写出
            os.close(); //接着关闭底层数据流os
        }
    }
}

import java.io.IOException;
import java.io.InputStream;

public class MyBis {
    //用于访问底层数据的底层流
    private InputStream is;
    //字节数组缓冲区
    byte[] buf;
    //默认缓存大小8k
    public static final int DEFAULT_BUF_SIZE = 8192;
    //记录缓冲区中 待读取的字节数
    private int count;
    //用于记录读取到当前 buf 中字节数据的位置
    private int pos;
    
    //构造方法
    public MyBis(InputStream is) throws Exception {
        this(is, DEFAULT_BUF_SIZE);
    }

    public MyBis(InputStream is, int size) throws Exception {
        if(size ) {
            throw new Exception("\"缓冲区空间大小分配错误：\" + size");
        }
        this.is = is;
        buf = new byte[DEFAULT_BUF_SIZE];
    }
    
    
    /**
     * 从缓冲区中读取下一个字节的数据，如果数据到到了末尾，返回 -1
     * @return 读取到的字节数据的 int 形式，如果读取到了流的末尾，返回 -1
     * @throws IOException 
     */
    public int read() throws IOException {
        if(pos == count) {//若读取的下一个字节数已经到达有效数据的末尾
            count = is.read(buf);//则通过底层的输入流，一次性读取 8192 个字节数据到缓冲区中来。
            if(-1 == count) {//若is 没有读取到数据，直接返回-1
                return -1;
            }
            //若is读取到数据了，将pos设置为第一个字节
            pos = 0;
        } 
        
        //返回读取到的字节数据的 int 形式
        return buf[pos++] & 0xff;
    }
    
    
    /**
     * 处理流的关闭问题：只关闭处理流即可，处理流的关闭会将底层的流关闭掉。
     * @throws IOException
     */
    public void close() throws IOException {
        if(null != is) {
            is.close();
        }
    }
}

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

public class TestMyBis {
    public static void main(String[] args) {
        MyBis mb = null;
        
        try {
            mb = new MyBis(new FileInputStream("./src/res/1.txt"));
            
            int value = 0;
            
            while(-1 != (value = mb.read())) {
                System.out.print((char)value);
            }
            
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if(null != mb) {
                try {
                    mb.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

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

public class BufferedStreamTest {
    public static void main(String[] args) {
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        
        try {
            //使用缓冲流
            bis = new BufferedInputStream(new FileInputStream("e:/test_file/data_structure.avi"));
            bos = new BufferedOutputStream(new FileOutputStream("e:/test_file/data_structure_copy.avi"));
            int len = 0;
            byte[] buf = new byte[1024*1024];//因为读取的源文件较大，所以这里分配的空间大一点
            
            while(-1 != (len = bis.read(buf))) {
                bos.write(buf, 0, len);
            }
            
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(null != bos) {
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(null != bis) {
                try {
                    bis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        
    }
}