摘要：簡介字節(jié)數(shù)組輸入流上一篇簡單的介紹了一下字節(jié)輸入流的超類，只提及了一下超類中定義的一些方法字節(jié)數(shù)組輸入流是超類的一個(gè)具體的實(shí)現(xiàn)主要的操作實(shí)際上就是讀取操作一個(gè)字節(jié)數(shù)組，類中定義了一個(gè)緩沖的字節(jié)數(shù)組，具體的操作通過定義一下標(biāo)志位，操作次數(shù)等進(jìn)

上一篇簡單的介紹了一下字節(jié)輸入流的超類，只提及了一下超類中定義的一些方法；字節(jié)數(shù)組輸入流是超類的一個(gè)具體的實(shí)現(xiàn)：主要的操作實(shí)際上就是讀取操作一個(gè)字節(jié)數(shù)組，類中定義了一個(gè)緩沖的字節(jié)數(shù)組，具體的操作通過定義一下標(biāo)志位，操作次數(shù)等進(jìn)行讀取該字節(jié)數(shù)組中的內(nèi)容；

1.介紹過程依據(jù)第一篇中的描述的過程；
（1）首先介紹類中的屬性內(nèi)容：

//存放字節(jié)流數(shù)組，實(shí)際的操作的數(shù)據(jù)內(nèi)容
protected byte buf[];
//當(dāng)前讀取的位置,在相關(guān)操作中會(huì)修改這個(gè)讀取位置
protected int pos;
//標(biāo)記讀取的位置，如果有需要標(biāo)記，可以使用mark()方法標(biāo)記位置
protected int mark = 0;
//字節(jié)流數(shù)組大小
protected int count;

（2）然后是定義構(gòu)造字節(jié)數(shù)組內(nèi)容：該類提供了兩種方式的構(gòu)造函數(shù)；第一種直接指定字節(jié)數(shù)組輸入流中緩沖的流數(shù)組，(這樣后續(xù)的讀取等操作都是在處理這個(gè)數(shù)組中的數(shù)據(jù))，該構(gòu)造函數(shù)中設(shè)置了上面提到的相關(guān)屬性；
第二種則指定了具體位置和大小，但實(shí)際的數(shù)據(jù)已全部在緩沖的數(shù)組中，只是確實(shí)了讀取的位置和大小，所以可以讀取的內(nèi)容比實(shí)際的內(nèi)容少；

public ByteArrayInputStream(byte buf[]) {
        this.buf = buf;
        this.pos = 0;
        this.count = buf.length;
    }
    
    public ByteArrayInputStream(byte buf[], int offset, int length) {
        this.buf = buf;
        this.pos = offset;
        this.count = Math.min(offset + length, buf.length);
        this.mark = offset;
    }

（3）判斷是否還能讀?。焊鶕?jù)當(dāng)前讀取的位置來確定是否還有數(shù)據(jù)

 public synchronized int available() {
        return count - pos;
    }

（4）具體的讀取數(shù)據(jù)：讀取操作及先判斷滿足讀取條件后讀取一個(gè)緩沖數(shù)組中的數(shù)據(jù)，并將讀取位置+1,&0xff的意義在于保證數(shù)據(jù)操作的一致性（計(jì)算機(jī)存儲(chǔ)數(shù)據(jù)機(jī)制方面）

 public synchronized int read() {
        return (pos < count) ? (buf[pos++] & 0xff) : -1;
    }
   

讀取數(shù)據(jù)到指定的字節(jié)數(shù)組中，可以指定讀取的位置和大小

public synchronized int read(byte b[], int off, int len) {
        if (b == null) {
            throw new NullPointerException();
        } else if (off < 0 || len < 0 || len > b.length - off) {
            throw new IndexOutOfBoundsException();
        }

        if (pos >= count) {
            return -1;
        }

        int avail = count - pos;
        if (len > avail) {
            len = avail;
        }
        if (len <= 0) {
            return 0;
        }
        System.arraycopy(buf, pos, b, off, len);
        pos += len;
        return len;
    }

（5）操作完記得關(guān)閉close();

1.skip（）跳過,忽略：及修改讀取位置

 public synchronized long skip(long n) {
        long k = count - pos;
        if (n < k) {
            k = n < 0 ? 0 : n;
        }

        pos += k;
        return k;
    }

2.mark():標(biāo)記位置，操作過程中標(biāo)記需要的位置，這樣在后面可以通過reset（）方法將讀取位置修改到這個(gè)值，這樣就可以再此從此位置讀取數(shù)據(jù)；

 public void mark(int readAheadLimit) {
        mark = pos;
    }

3.reset():上面介紹過了，

 public synchronized void reset() {
        pos = mark;
    }

/**
 1. 數(shù)組字節(jié)輸入流
 */
public class MyByteArrayInputStream {
    
    //存放字節(jié)流數(shù)組
    protected byte buffer[];
    
    //當(dāng)前讀取的位置
    protected int position;
    
    //字節(jié)流數(shù)組大小
    protected int counts;
    
    //標(biāo)記讀取的位置
    protected int mark;
    
    /**
     * 指定字節(jié)數(shù)組構(gòu)造輸入流
     * @param buf 指定數(shù)組
     */
    public MyByteArrayInputStream(byte[] buf) {
       this.buffer = buf;
       this.counts = buf.length;
    }
    
    public MyByteArrayInputStream(byte[] buf,int offset,int length) {
        this.position = offset;
        this.mark = offset;
        this.buffer = buf;
        this.counts = Math.min(buf.length, length+offset);
     }
    
    //讀取字節(jié)數(shù)組中的字節(jié)流
    public synchronized int read(){
        return positioncounts){
            return -1;
        }
        //
        int can = counts - position;
        if(length > can){
            length = can;
        }
        
        if(length <=0){
            return 0;
        }
        System.arraycopy(buffer, position, buf, offset, length);
        position += length;
        return length;
    }

    //跳過字節(jié)數(shù)組中的n個(gè)字節(jié)
    public synchronized long skip(long n){
        //當(dāng)前可讀取的數(shù)量
        long can = counts-position;
        //當(dāng)跳過的大小小于可讀取的數(shù)量時(shí)
        if(n < can){
            //值大于0 設(shè)置跳過的次數(shù)為 n ,否則為0；
            can = n < 0 ? 0 : n;
        }
        //設(shè)置當(dāng)前讀取的位置，跳過n個(gè)
        position +=can;
        //返回實(shí)際跳過的值
        return can;
    }
    
    //是否支持標(biāo)記，支持
    public boolean markSupported(){
        return true;
    }
    
    //標(biāo)記當(dāng)前讀取的位置，與重置相對，標(biāo)記之后，使用重置方法可以在指定位置讀取
    public void mark(){
        mark = position;
    }
    //設(shè)置當(dāng)前讀取的位置為上一次標(biāo)記的位置
    public synchronized void reset(){
        position = mark;
    }
    //剩余可以去到的數(shù)量
    public synchronized int available(){
        return  counts-position;
    }
    
    //關(guān)閉操作
    public void close() throws IOException {
    }
}

## 4. 最后召喚神獸##

/**
 *                  ___====-_  _-====___
 *            _--^^^#####//      #####^^^--_
 *         _-^##########// (    ) ##########^-_
 *        -############//  |^^/|  ############-
 *      _/############//   (@::@)   ############\_
 *     /#############((     //     ))#############
 *    -###############    (oo)    //###############-
 *   -#################  / VV   //#################-
 *  -###################/      //###################-
 * _#/|##########/######(   /   )######/##########|#_
 * |/ |#/#/#//  #/##  |  |  /##/#/  /#/#/#| |
 * `  |/  V  V  `   V  #| |  | |/#/  V   "  V  V  |  "
 *    `   `  `      `   / | |  | |    "      "  "   "
 *                     (  | |  | |  )
 *                    __ | |  | | /__
 *                   (vvv(VVV)(VVV)vvv)                
 *                        神獸保佑
 *                       代碼無BUG!
 */