上一篇簡單介紹了輸出流的超類OutputStream,也大概的講述了輸出流的作用，本篇就介紹一下，輸出流的一種實(shí)現(xiàn)，字節(jié)數(shù)組輸出流，該輸出流是為了處理字節(jié)的基礎(chǔ)流，本質(zhì)上就是寫入數(shù)據(jù)到類中的緩沖字節(jié)數(shù)組中;

(1)屬性內(nèi)容：屬性內(nèi)容相較輸入流的會有存放數(shù)據(jù)的緩沖區(qū)，也就是字節(jié)數(shù)組；
count：寫操作的時(shí)候的計(jì)數(shù)，也可以算作數(shù)據(jù)的大小

// 存儲數(shù)據(jù)的緩沖區(qū)(字節(jié)數(shù)組)。
protected byte buf[];
//緩沖區(qū)中的有效字節(jié)數(shù)(寫入的內(nèi)容大小，也可以看做是位置)
protected int count;

（2）構(gòu)造函數(shù)：默認(rèn)的構(gòu)造函數(shù)會初始化緩沖區(qū)大小為32個(gè)字節(jié)，即緩沖數(shù)組的大小為32；

    //默認(rèn)構(gòu)造函數(shù)
    public ByteArrayOutputStream() {
        this(32);
    }

    //指定的緩沖區(qū)大小
    public ByteArrayOutputStream(int size) {
        if (size < 0) {
            throw new IllegalArgumentException("Negative initial size: "
                                               + size);
        }
        buf = new byte[size];
    }

（3）主要方法：輸出流的主要方法當(dāng)然就是寫，ByteArrayOutputStream中有三種寫方法，第一是寫入一個(gè)int 數(shù)據(jù)以字節(jié)的形式存到緩沖數(shù)組中，第二個(gè)就是寫入指定的字節(jié)數(shù)組，可以指定從該數(shù)組的哪個(gè)位置開始寫，和寫多少；最后一個(gè)是寫到指定的輸出流中，相當(dāng)于繼續(xù)流，

// 將指定的字節(jié)寫入此 byte 數(shù)組輸出流。
public synchronized void write(int b) {
        ensureCapacity(count + 1);
        buf[count] = (byte) b;
        count += 1;
    }
//將指定 byte 數(shù)組中從偏移量 off 開始的 len 個(gè)字節(jié)寫入此 byte 數(shù)組輸出流。
public synchronized void write(byte b[], int off, int len) {
        if ((off < 0) || (off > b.length) || (len < 0) ||
            ((off + len) - b.length > 0)) {
            throw new IndexOutOfBoundsException();
        }
        ensureCapacity(count + len);
        System.arraycopy(b, off, buf, count, len);
        count += len;
    }
//將此 byte 數(shù)組輸出流的全部內(nèi)容寫入到指定的輸出流參數(shù)中
public synchronized void writeTo(OutputStream out) throws IOException {
        out.write(buf, 0, count);
    }

擴(kuò)容方法：
在上面的寫方法中我們可以看到其中還有一個(gè)中間處理的方法，也就是擴(kuò)容的方法，在數(shù)據(jù)寫入的過程中，每次會判斷當(dāng)前的緩沖區(qū)容量是否夠?qū)懭?，如果不夠就兩倍擴(kuò)容；

//判斷是否需要擴(kuò)容
private void ensureCapacity(int minCapacity) {
        // overflow-conscious code
        if (minCapacity - buf.length > 0)
            grow(minCapacity);
    }

//進(jìn)行擴(kuò)容操作
private void grow(int minCapacity) {
        int oldCapacity = buf.length;
        int newCapacity = oldCapacity << 1;
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity < 0) {
            if (minCapacity < 0) // overflow
                throw new OutOfMemoryError();
            newCapacity = Integer.MAX_VALUE;
        }
        buf = Arrays.copyOf(buf, newCapacity);
    }

（4）其他方法介紹
reset():重置方法僅僅是將count值設(shè)置為0，這樣寫數(shù)據(jù)的時(shí)候就可以重新從0開始寫，此時(shí)緩沖區(qū)的數(shù)據(jù)其實(shí)還存在；

public synchronized void reset() {
        count = 0;
    }

size():返回當(dāng)前寫入了多少數(shù)據(jù)，其實(shí)就是count的值；

public synchronized int size() {
        return count;
    }

toByteArray():以字節(jié)數(shù)組的形式返回當(dāng)前緩沖數(shù)組中的數(shù)據(jù)，當(dāng)然位置是從0，到count,所以reset操作之后即使緩沖數(shù)組中的數(shù)據(jù)很多，但只顯示到count;

 public synchronized byte toByteArray()[] {
        return Arrays.copyOf(buf, count);
    }

還有toString()的方法：字符串顯示，類似toByteArray();

只實(shí)現(xiàn)核心的方法功能，沒有繼承其他類；

//字節(jié)數(shù)組輸出流
public class MyByteArrayOutputStream {
    
    //緩沖的字節(jié)數(shù)組
    protected byte[] buffer;
    
    //輸出流的內(nèi)容大小，寫入的大小
    protected int counts;
    
    //默認(rèn)構(gòu)造初始化時(shí)定義32字節(jié)大小的緩沖數(shù)組空間
    public MyByteArrayOutputStream() {
       this(32);
    }
    //創(chuàng)建指定大小的緩沖數(shù)組空間
    public MyByteArrayOutputStream(int size) {
        if(size<0){
            throw new IllegalArgumentException("size 值必須大于0"+size);
        }
        buffer = new byte[size];
    }
    
    //輸出流寫入一個(gè)int b :即將數(shù)據(jù)寫到緩沖數(shù)組中
    public synchronized void write(int b){
        //每次寫數(shù)據(jù)前判斷當(dāng)前緩沖數(shù)組空間是否夠?qū)懭?，不夠則進(jìn)行擴(kuò)容
        ensureCapacity(counts+1);
        buffer[counts] = (byte)b;
        //統(tǒng)計(jì)寫入的大小
        counts+=1;
    }

    //從指定的字節(jié)數(shù)組向輸出流中寫數(shù)據(jù)，可以指定數(shù)組中的啥位置開始寫入，和寫多少
    public synchronized void write(byte[] b,int offset,int length){
        if(b==null){
            throw new NullPointerException();
        }else if((offset < 0) ||(b.length buffer.length){
            growCapacity(capacity);
        }
    }
    
    //擴(kuò)容方法：兩倍當(dāng)前容量進(jìn)行擴(kuò)容，如果兩倍容量還小于需要的容量，則使用需要的容量，當(dāng)然最大不能超過數(shù)組的最大容量
    private void growCapacity(int capacity){
        int oldCapacity = buffer.length;
        int newCapacity = oldCapacity << 1;
        if(newCapacity < capacity){
            newCapacity = capacity;
        }
        if(newCapacity < 0){
            if(capacity<0){
                throw new IndexOutOfBoundsException("增加的容量不正常");
            }
            newCapacity=Integer.MAX_VALUE;
        }
        buffer = Arrays.copyOf(buffer, newCapacity);
    }
    
    //重置：將寫入的位置設(shè)置為0，這樣就可以從0位置寫數(shù)據(jù)，重置后緩沖數(shù)組中可能存在之前的數(shù)據(jù)
    public synchronized void reset(){
        counts = 0;
    }
}

/**
 *
 *                                                    __----~~~~~~~~~~~------___
 *                                   .  .   ~~//====......          __--~ ~~
 *                   -.            \_|//     |||  ~~~~~~::::... /~
 *                ___-==_       _-~o~  /    |||              _/~~-
 *        __---~~~.==~||=_    -_--~/_-~|-   |           _/~
 *    _-~~     .=~    |  -_    "-~7  /-   /  ||          /
 *  .~       .~       |    -_    /  /-   /   ||         /
 * /  ____  /         |      ~-_/  /|- _/   .||        /
 * |~~    ~~|--~~~~--_      ~==-/   | ~--===~~        .
 *          "         ~-|      /|    |-~~~       __--~~
 *                      |-~~-_/ |    |   ~\_   _-~            /
 *                           /       \__   /~                \__
 *                       _--~ _/ | .-~~____--~-/                  ~~==.
 *                      ((->/~   ".|||" -_|    ~~-/ ,              . _||
 *                                 -_     ~      ~~---l__i__i__i--~~_/
 *                                 _-~-__   ~)  --______________--~~
 *                               //.-~~~-~_--~- |-------~~~~~~~~
 *                                      //.-~~~--
 *                               神獸保佑
 *                              代碼無BUG!