Java_io体系之BufferedInputStream、BufferedOutputStream简介、走进源码及示例——10

	private static int defaultBufferSize = 8192;//内置缓存字节数组的大小
	
	protected volatile byte buf[];	内置缓存字节数组
	
	protected int count;	当前buf中的字节总数、注意不是底层字节输入流的源中字节总数
	
	protected int pos;		当前buf中下一个被读取的字节下标
	
	protected int markpos = -1;		最后一次调用mark(int readLimit)方法记录的buf中下一个被读取的字节的位置
	
	protected int marklimit;	调用mark后、在后续调用reset()方法失败之前云寻的从in中读取的最大数据量、用于限制被标记后buffer的最大值

	BufferedInputStream (InputStream in);	使用默认buf大小、底层字节输入流构建bis
	
	BufferedInputStream (InputStream in, int size);		使用指定buf大小、底层字节输入流构建bis

	int available();	返回底层流对应的源中有效可供读取的字节数	
	
	void close();	关闭此流、释放与此流有关的所有资源
	
	boolean markSupport();	查看此流是否支持mark、此方法一直返回true
	
	void mark(int readLimit);	标记当前buf中读取下一个字节的下标
	
	int read();		读取buf中下一个字节
	
	int read(byte[] b, int off, int len);		读取buf中下一个字节
	
	void reset();	重置最后一次调用mark标记的buf中的位子
	
	long skip(long n);	跳过n个字节、 不仅仅是buf中的有效字节、也包括in的源中的字节

package com.chy.io.original.code;
import java.io.IOException;
import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
 
/**
 * BufferedInputStream 缓冲字节输入流、作为FilterInputStream的一个实现类、为子类添加缓冲功能、自带一个缓冲数组、
 * 是为传入的InputStream的实现类（简称in）提供缓冲读取功能、他的原理是从in中一次性读取一个数据块放入自带的缓冲数组中、
 * 当这个缓冲数组中的数据被读取完时、BufferedInputStream再从in中读取一个数据块、这样循环读取。
 * 缓存数组是放在内存中的、当程序从buf中读取字节的时候、相当于从内存中读取、从内存中读取的效率至少是从磁盘等存储介质的十倍以上！
 * 这里会有人想干嘛不一次性读取所有in中的字节放入内存中？
 * 1）读取全部字节可能耗费的时间较长、
 * 2）内存有限、不想磁盘等存储介质存储空间那么大、价格也相对昂贵的多！
 * 
 */
public class BufferedInputStream extends FilterInputStream {
 
//	BufferedInputStream自带的数组大小
    private static int defaultBufferSize = 8192;
 
    /**
     *自带数组、如果在根据传入的in构造BufferedInputStream没有传入时、其大小为8192、
     *如果传入则使用传入的大小。
     */
    protected volatile byte buf[];
 
    /**
     * 缓存数组的原子更新器。
 	 * 该成员变量与buf数组的volatile关键字共同组成了buf数组的原子更新功能实现，
 	 * 即，在多线程中操作BufferedInputStream对象时，buf和bufUpdater都具有原子性(不同的线程访问到的数据都是相同的)
     */
    private static final 
        AtomicReferenceFieldUpdater<BufferedInputStream, byte[]> bufUpdater = 
        AtomicReferenceFieldUpdater.newUpdater
        (BufferedInputStream.class,  byte[].class, "buf");
 
    /**
     *当前缓冲字节数组中的有效可供读取的字节总数。
     *注意这里是缓冲区、即缓冲数组buf中的有效字节、而不是in中有效的字节
     */
    protected int count;
 
    /**
     * 用于标记buf中下一个被读取的字节的下标、即下一个被读取的字节是buf[pos]、pos取值范围一般是 0 到count、
     * 如果pos = count则说明这个buf中的字节被读取完、那么需要从in中读取下一个数据块用于读取。
     * 同样：这里指的是缓冲字节数组中字节的下标、而不是in中的字节的下标
     */
    protected int pos;
    
    /**
     * 当前缓冲区的标记位置、
     * mark() reset()结合使用步骤（单独使用没有意义）
     * 1）调用mark()、将标记当前buf中下一个要被读取的字节的索引 pos保存到 markpos中
     * 2）调用reset()、将markpos的值赋给pos、这样再次调用read()的时候就会从最后一次调用mark方法的位置继续读取。
     */
    protected int markpos = -1;
 
    /**
     * 调用mark方法后、在后续调用reset()方法失败之前所允许的最大提前读取量。
     */
    protected int marklimit;
 
    /**
     * 检测传入的基础流in是否关闭。若没有关闭则返回此流。
     */
    private InputStream getInIfOpen() throws IOException {
        InputStream input = in;
		if (input == null){
		    throw new IOException("Stream closed");
		} 
		return input;
    }
 
    /**
     *检测BufferedInputStream是否关闭、如果没有关闭则返回其自带缓存数组buf。
     */
    private byte[] getBufIfOpen() throws IOException {
        byte[] buffer = buf;
		if (buffer == null)
		    throw new IOException("Stream closed");
        return buffer;
    }
 
    /**
     * 使用BufferedInputStream默认的缓冲字节数组大小及传入的基础输入字节流in创建BufferedInputStream。
     */
    public BufferedInputStream(InputStream in) {
    	this(in, defaultBufferSize);
    }
 
    /**
     * 使用传入的缓冲字节数组大小及传入的基础输入字节流in创建BufferedInputStream。
     */
    public BufferedInputStream(InputStream in, int size) {
		super(in);
	        if (size <= 0) {
	            throw new IllegalArgumentException("Buffer size <= 0");
	        }
		buf = new byte[size];
    }
 
    /**
     * 从输入流in中获取字节、填充到缓冲字节数组中。这里由于时间关系没有过于纠结内部实现、有兴趣的可以自己研究下
     */
    private void fill() throws IOException {
        byte[] buffer = getBufIfOpen();
		if (markpos < 0){
			pos = 0;		/* no mark: throw away the buffer */
		}else if (pos >= buffer.length){	/* no room left in buffer */
		    if (markpos > 0) {	/* can throw away early part of the buffer */
				int sz = pos - markpos;
				System.arraycopy(buffer, markpos, buffer, 0, sz);
				pos = sz;
				markpos = 0;
		    } else if (buffer.length >= marklimit) {
				markpos = -1;	/* buffer got too big, invalidate mark */
				pos = 0;	/* drop buffer contents */
		    } else {		/* grow buffer */
		    	int nsz = pos * 2;
				if (nsz > marklimit){
					nsz = marklimit;
				}
				byte nbuf[] = new byte[nsz];
				System.arraycopy(buffer, 0, nbuf, 0, pos);
                if (!bufUpdater.compareAndSet(this, buffer, nbuf)) {
                    // Can't replace buf if there was an async close.
                    // Note: This would need to be changed if fill()
                    // is ever made accessible to multiple threads.
                    // But for now, the only way CAS can fail is via close.
                    // assert buf == null;
                    throw new IOException("Stream closed");
                }
                buffer = nbuf;
		    }
		}    
	    count = pos;
		int n = getInIfOpen().read(buffer, pos, buffer.length - pos);
        if (n > 0){
        	//根据从输入流中读取的实际数据的多少，来更新buffer中数据的实际大小
        	count = n + pos;
        }
    }
 
    /**
     * 读取下一个字节、并以整数形式返回。
     */
    public synchronized int read() throws IOException {
		if (pos >= count) {
			// 若已经读完缓冲区中的数据，则调用fill()从输入流读取下一部分数据来填充缓冲区
		    fill();
		    //读取完in最后一个字节。
		    if (pos >= count)
			return -1;
		}
		return getBufIfOpen()[pos++] & 0xff;
    }
 
    /**
     * 将缓存字节数组中的字节写入到从下标off开始、长度为len的byte[]b 中。
     */
    private int read1(byte[] b, int off, int len) throws IOException {
		int avail = count - pos;
		if (avail <= 0) {
		    /** 
		     * 如果传入的byte[]的长度len大于buf的size、并且没有markpos、就直接从原始流中读取len个字节放入byte[]b中
		     * 避免不必要的copy：从原始流中读取buf.length个放入buf中、再将buf中的所有字节放入byte[]b 中
		     * 再清空buf、再读取buf.length个放入buf中 、还要放入byte[]b中直到 len个。
		     */
		    if (len >= getBufIfOpen().length && markpos < 0) {
		    	return getInIfOpen().read(b, off, len);
		    }
		    //若缓冲区数据被读取完、则调用fill()填充buf。
		    fill();
		    avail = count - pos;
		    if (avail <= 0) return -1;
		}
		int cnt = (avail < len) ? avail : len;
		System.arraycopy(getBufIfOpen(), pos, b, off, cnt);
		pos += cnt;
		return cnt;
    }
 
    /**
     * 将buf中的字节读取到下标从off开始、len长的byte[]b 中
     */
    public synchronized int read(byte b[], int off, int len)
	throws IOException
    {
        getBufIfOpen(); // Check for closed stream
        if ((off | len | (off + len) | (b.length - (off + len))) < 0) {
		    throw new IndexOutOfBoundsException();
		} else if (len == 0) {
	            return 0;
	        }
        /**
         * 不断的读取字节、放入b中、有以下几种情况
         * 1）buf中有len个可供读取、则将len个字节copy到b中
         * 2）buf中不足len个、从源输入流中读取下一个数据块
         * 	  a）源输入流中有可供读取的有效的、读取并填充buf、继续填充到b中
         * 	  b）读到结尾、依然不够、将所有读取的填充到b中
         */
        
		int n = 0;
        for (;;) {
            int nread = read1(b, off + n, len - n);
            if (nread <= 0) 
                return (n == 0) ? nread : n;
            n += nread;
            if (n >= len)
                return n;
            // if not closed but no bytes available, return
            InputStream input = in;
            if (input != null && input.available() <= 0)
                return n;
        }
    }
 
    /**
     * 跳过n个字节、返回实际跳过的字节数。
     */
    public synchronized long skip(long n) throws IOException {
        getBufIfOpen(); // Check for closed stream
		if (n <= 0) {
		    return 0;
		}
		long avail = count - pos;
     
        if (avail <= 0) {
            // If no mark position set then don't keep in buffer
            if (markpos <0) 
                return getInIfOpen().skip(n);
            
            // Fill in buffer to save bytes for reset
            fill();
            avail = count - pos;
            if (avail <= 0)
                return 0;
        }
        
        long skipped = (avail < n) ? avail : n;
        pos += skipped;
        return skipped;
    }
 
    /**
     * 返回in中有效可供被读取的字节数。从这里也可以看出、有效字节是in中现有有效字节与buf中剩余字节的和。
     * 即buf中是从in中读取的一个供程序读取的数据块。
     */
    public synchronized int available() throws IOException {
    	return getInIfOpen().available() + (count - pos);
    }
 
    /** 
     * @param   readlimit   在mark方法方法失效前最大允许读取量
     */
    public synchronized void mark(int readlimit) {
		marklimit = readlimit;
		markpos = pos;
    }
 
    /**
     * 将最后一次调用mark标记的位置传递给pos、使得此流可以继续接着最后一次mark的地方读取。
     * 如果没有调用mark、或者mark失效则抛出IOException。
     */
    public synchronized void reset() throws IOException {
        getBufIfOpen(); // Cause exception if closed
		if (markpos < 0)
		    throw new IOException("Resetting to invalid mark");
		pos = markpos;
    }
 
    /**
     * 查看此流是否支持markSupport
     * @return true 此流支持mark。
     */
    public boolean markSupported() {
    	return true;
    }
 
    /**
     * 关闭此流并释放所有资源。
     */
    public void close() throws IOException {
        byte[] buffer;
        while ( (buffer = buf) != null) {
            if (bufUpdater.compareAndSet(this, buffer, null)) {
                InputStream input = in;
                in = null;
                if (input != null)
                    input.close();
                return;
            }
        }
    }
}

当使用BufferedInputStream时、一般就是冲着他的缓冲功能去的、其他的方法在前面底层的类中有代码、使用方法、效果完全相同只是内部实现不同、这里对于BufferedInputStream、BufferedOutputStream的实例放在一起的、可见下面。

	protected byte[] buf;	内置缓存字节数组、用于存放程序要写入out的字节
	
	protected int count;	内置缓存字节数组中现有字节总数

	BufferedOutputStream(OutputStream out);		使用默认大小、底层字节输出流构造bos
	
	BufferedOutputStream(OutputStream out, int size);	使用指定大小、底层字节输出流构造bos

	//在这里提一句、BufferedOutputStream没有自己的close方法、当他调用父类FilterOutputStrem的方法关闭时、会间接调用自己实现的flush方法将buf中残存的字节flush到out中、再out.flush()到目的地中、DataOutputStream也是如此、
	
	void  flush();	将写入bos中的数据flush到out指定的目的地中、注意这里不是flush到out中、因为其内部又调用了out.flush()
	
	write(byte b);		将一个字节写入到buf中
	
	write(byte[] b, int off, int len);		将b的一部分写入buf中

package com.chy.io.original.code;
 
import java.io.IOException;
 
/**
 * 为传入的基础输出流（以下简称 out）提供缓冲功能、先将要写入out的数据写入到BufferedOutputStream缓冲数组buf中、
 * 当调用bufferedOutputStream的flush()时、或者调用flushBuffer()时一次性的将数据使用out.write(byte[]b , 0, count)写入out指定的目的地中、
 * 避免out.write(byte b)方法每写一个字节就访问一次目的地。
 * 
 */
public class BufferedOutputStream extends FilterOutputStream {
    /**
     * BufferedOutputStream内置的缓存数组、当out进行写入时、BufferedOutputStream会先将out写入的数据
     * 放到buf中、
     * 注意：不一定buf[]被写满之后才会写入out中。
     */
    protected byte buf[];
 
    /**
     * 缓存数组中现有的可供写入的有效字节数、
     * 注意：这里是buf中的、而不是out中的。
     */
    protected int count;
    
    /**
     * 使用BufferedOutputStream默认的缓存数组大小与基础输出流out创建BufferedOutputStream。
     */
    public BufferedOutputStream(OutputStream out) {
    	this(out, 8192);
    }
 
    /**
     * 使用指定的的缓存数组大小与基础输出流out创建BufferedOutputStream。
     */
    public BufferedOutputStream(OutputStream out, int size) {
	super(out);
        if (size <= 0) {
            throw new IllegalArgumentException("Buffer size <= 0");
        }
        buf = new byte[size];
    }
 
    /** 如果buf中有的数据、则立刻将buf中所有数据写入目的地中。 并且将count重置为0。*/
    private void flushBuffer() throws IOException {
        if (count > 0) {
		    out.write(buf, 0, count);
		    count = 0;
        }
    }
 
    /**
     * 将要写入out中的数据先写入到buf中。
     */
    public synchronized void write(int b) throws IOException {
		if (count >= buf.length) {
		    flushBuffer();
		}
		buf[count++] = (byte)b;
    }
 
    /**
     * 将从下标off开始、长度为len个字节的byte[]b写入buf中、
     */
    public synchronized void write(byte b[], int off, int len) throws IOException {
		if (len >= buf.length) {
		    /* 如果写入的字节个数超过buf的长度、
		     * 那么直接调用out.write(byte b[] , int off, int len)避免重复操作、即读到buf中但buf立马装满
		     * 此时将buf写入out中又将剩下的填充到buf中。
		     */
		    flushBuffer();
		    out.write(b, off, len);
		    return;
		}
		//如果写入的个数大于buf中现有剩余空间、则将buf中的现有count个字节写入out中、注意：flushBuffer之后、count变成了0。
		//再将len个字节写入从count下标开始长度为len的buf中。
		//同时将count 变成 count +=len.
		if (len > buf.length - count) {
		    flushBuffer();
		}
		System.arraycopy(b, off, buf, count, len);
		count += len;
    }
 
    /**
     * 1）将buf中现有字节写入out中
     * 2）将out中的现有字节flush到目的地中。
     */
    public synchronized void flush() throws IOException {
        flushBuffer();
        out.flush();
    }
}

package com.chy.io.original.test;
 
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
 
public class BufferedStreamTest {
	
	private static final byte[] byteArray = {
        0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F,
        0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A
    };
	public static void testBufferedOutputStream() throws IOException{
		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(new File("D:\\bos.txt")));
		bos.write(byteArray[0]);
		bos.write(byteArray, 1, byteArray.length-1);
		//bos.write(byteArray); 注意：这个方法不是BufferedOutputStream的方法、此方法是调用FilterOutputStream的write(byte[] b)
		//write(byte[] b)调用本身的write(byte[]b , 0, b.length)方法、而此方法的本质是循环调用传入的out的out.write(byte b)方法.
		bos.flush();
	}
	
	public static void testBufferedInpuStream() throws IOException{
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream(new File("D:\\bos.txt")));
		for(int i=0; i<10; i++){
			if(bis.available() >=0){
				System.out.println(byteToString((byte)bis.read()));
			}
		}
		if(!bis.markSupported()){
			return;
		}
		
		bis.mark(6666);//标记"当前索引位子" 即第11个字节 k
		
		bis.skip(10);//丢弃10个字节。
		
		//读取剩下的b.length个字节
		byte[] b = new byte[1024];
		int n1 = bis.read(b, 0, b.length);
		System.out.println("剩余有效字节 : " +n1);
		printByteValue(b);
		
		bis.reset();//重置输入流最后一次调用mark()标记的索引位置
		int n2 = bis.read(b, 0, b.length);
		System.out.println("剩余有效字节 : " +n2);
		printByteValue(b);
	}
	private static void printByteValue(byte[] buf) {
		for(byte b : buf){
			if(b != 0){
				System.out.print(byteToString(b) + " ");
			}
		}
	}
	
	private static String byteToString(byte b){
		byte[] bAray = {b};
		return new String (bAray);
	}
	
	public static void main(String[] args) throws IOException {
		testBufferedOutputStream();
		testBufferedInpuStream();
	}
}

对实例的一些补充：这里没有体现出使用这两个类的上面层吹的天花的优点、仅仅是简单的方法、留个坑、有时间弄个实例测试一下读取的效率、、一般这两个类最长用的是包装文件流（当然也可以是其他的流）、有兴趣的可以自己拿被包装的FileInputStream、FileOutputStream、和裸的这两个流、拷贝一个大文件看看差距。