자바 IO 흐름 의 ByteArray InputStream 분석

간단 한 소개
    ByteArray InputStream 은 바이트 배열 의 입력 흐름 입 니 다.메모리 에 바이트 배열 을 만 들 었 습 니 다.입력 흐름 에서 읽 은 데 이 터 를 바이트 배열 의 캐 시 영역 에 저장 합 니 다.즉,바이트 배열 의 입력 흐름 은 읽 은 데 이 터 를 바이트 배열 버퍼 에 저장 합 니 다.
    1.ByteArray InputStream 구조 방법 은 두 가지 가 있 습 니 다.

public ByteArrayInputStream(byte buf[]) {}
public ByteArrayInputStream(byte buf[], int offset, int length) {}

첫 번 째 구조 방법 은 바이트 배열 buf.

를 받 는 것 이다.

두 번 째 구조 방법 은 바이트 배열 buf 입 니 다.offset 은 오프셋 입 니 다.배열 에서 데 이 터 를 읽 는 색인 시작 위치 입 니 다.length 는 offset 색인 에서 바이트 의 길 이 를 읽 습 니 다.즉,buf 배열 에서 offset 에서 offset+length 사이 의 데 이 터 를 읽 습 니 다.

    2.내부 변수

protected byte buf[];
protected int pos;
protected int mark = 0;
protected int count;

buf 는 바이트 입력 스 트림 데 이 터 를 저장 하 는 바이트 배열 입 니 다.

pos 는 배열 의 다음 바이트 의 색인 을 읽 는 것 으로 정수 이 며 크기 는 0 에서 count 입 니 다.

mark 는 표 시 된 색인 입 니 다.mark()방법 과 reset()방법 으로 설정 할 수 있 습 니 다.설정 하지 않 을 때 첫 번 째 구조 방법 을 호출 할 때 0 이 고 두 번 째 구조 방법 을 호출 할 때 mark 값 은 offset 으로 설정 할 수 있 습 니 다.

count 는 바이트 흐름 의 길이 입 니 다.첫 번 째 구조 방법 을 사용 할 때 길 이 는 바이트 배열 buf 의 length 입 니 다.두 번 째 구조 방법 을 사용 할 때 길 이 는 offset+length 와 buf.length 의 작은 값 입 니 다.

    3.내부 방법

public synchronized int read()
public synchronized int read(byte b[], int off, int len) {}
public synchronized long skip(long n) {}
public synchronized int available() {}
public boolean markSupported() {}
public void mark(int readAheadLimit) {}
public synchronized void reset() {}
public void close() throws IOException{}

read():다음 바이트 읽 기,다 읽 으 면-1

로 돌아 갑 니 다.

read(byte b[],int off,int len):바이트 배열 b,off 위치 부터 읽 고 길 이 는 len 의 데이터 입 니 다.

skip(long n):바이트 흐름 에서 n 바이트 건 너 뛰 기.건 너 뛰 는 지 안 건 너 뛰 는 지 주의 하 세 요.

available():남 은 읽 을 수 있 는 바이트 수 를 표시 합 니 다.

markSupported():mark()/reset()을 지원 하 는 지 여부 입 니 다.이 값 은 항상 true 를 되 돌려 줍 니 다.

mark(int readAhead Limit):현재 위 치 를 표시 합 니 다.readAhead Limit 은 여기 서 의미 가 없습니다.

reset():버퍼 의 위 치 를 mark 표 시 된 위치 로 초기 화 합 니 다.

close():흐름 을 닫 습 니 다.흐름 이 닫 힌 경우 바이트 입력 흐름 의 다른 방법 을 호출 하여 이상 을 던 지지 않 습 니 다.

 
케이스

public class ByteArrayInputStreamDemo {
  public static void main(String[] args) {
    byte[] bytes = "abcdefghijklmnopqrst".getBytes();
    ByteArrayInputStream byteStream = new ByteArrayInputStream(bytes);
    //avaiable        ,  a,  19   
    if(byteStream.available()>0) {
      System.out.println((char)byteStream.read()+"------       ="+byteStream.available());
    }
    for(int i  = 0 ; i < 3;i++) {
      if(byteStream.available()>0) {
        System.out.println((char)byteStream.read());
      }
    }
    //     d,  3   ,      h
    long skip = byteStream.skip(3);
    System.out.println((char)byteStream.read()+"-----     ="+skip);
    if(byteStream.markSupported()) {
      System.out.println("support mark");
    }
    //      i,    .
    byteStream.mark(0);
    //      ,         .
    byte[] byteArray = new byte[3];
    byteStream.read(byteArray, 0, 2);
    System.out.println(new String(byteArray));
    //  reset()        mark  
    byteStream.reset();
    System.out.println((char)byteStream.read());
    
  }

실행 결과:

a------       =19
b
c
d
h-----     =3
support mark
ij

코드 분석:
(a)read()방법 은 한 바이트 만 읽 을 수 있 고 다음 바이트 만 읽 을 수 있 습 니 다.
(b)read(buf,offset,len)방법 으로 바이트 배열 buf 를 만 들 고 스 트림 의 데 이 터 를 buf 에 읽 습 니 다.위 치 는 offset 부터 시작 합 니 다.길 이 는 len 입 니 다.
(c)available()는 읽 을 수 있 는 바이트 수 를 표시 합 니 다.코드 에서 a 를 읽 었 을 때 읽 을 수 있 는 바이트 수 는 19 바이트 가 남 았 습 니 다.
(d)mark()는 다음 바이트 의 위 치 를 표시 합 니 다.뒤의 몇 바이트 까지 읽 은 후에 reset()를 사용 하여 이 위치 로 다시 돌아 갈 수 있 습 니 다.
(e)skip(n):건 너 뛰 는 바이트 수 를 표시 합 니 다.다음 바이트 부터 계산 합 니 다.코드 에 서 는 e 가 계산 하기 시 작 했 습 니 다.3 개의 바 이 트 를 건 너 뛰 고 g 가 끝 날 때 까지 입 니 다.다음 읽 는 바 이 트 는 h 입 니 다.
소스 코드 분석

public class ByteArrayInputStream extends InputStream {

  //               
  protected byte buf[];

  //              
  protected int pos;

  //      
  protected int mark = 0;

  //      
  protected int count;

  //     --       buf        
  public ByteArrayInputStream(byte buf[]) {
    this.buf = buf;
    //               0
    this.pos = 0;
    //          ,count     buf.length
    this.count = buf.length;
  }

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

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

  //            b ,off              ,len     
  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();
    }
    //               count,        
    if (pos >= count) {
      return -1;
    }
    // len           ,len            
    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;
  }

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

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

  //       ,       true
  public boolean markSupported() {
    return true;
  }

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

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

  //              ,      
  public void close() throws IOException {}
}

원본 코드 요약:
(a)count 실제 상류 내용 은 바이트 배열 에서 사용 할 수 있 는 색인 값+1 입 니 다.읽 을 때 다음 읽 을 색인 pos 와 count 를 비교 합 니 다.count 보다 작 을 때 스 트림 바이트 데이터 에 이 색인 이 존재 하기 때문에 스 트림 내용 을 읽 을 수 있 습 니 다.
(b)스 트림 에 있 는 데이터 나 내용 은 구조 함수 에 있 는 buf 바이트 배열 과 offset 과 읽 기 길이 len 을 봐 야 합 니 다.아래 read(by te[]b,int off,int len)는 스 트림 에 있 는 내용 을 바이트 배열 에 읽 는 것 을 의미 합 니 다.두 가 지 는 구분 에 주의해 야 합 니 다.