java io系列02之 ByteArrayInputStream的简介,源码分析和示例(包括InputStream)

 1 package java.io;
 2 
 3 public abstract class InputStream implements Closeable {
 4 
 5     // 能skip的大小
 6     private static final int MAX_SKIP_BUFFER_SIZE = 2048;
 7 
 8     // 从输入流中读取数据的下一个字节。
 9     public abstract int read() throws IOException;
10 
11     // 将数据从输入流读入 byte 数组。
12     public int read(byte b[]) throws IOException {
13         return read(b, 0, b.length);
14     }
15 
16     // 将最多 len 个数据字节从此输入流读入 byte 数组。
17     public int read(byte b[], int off, int len) throws IOException {
18         if (b == null) {
19             throw new NullPointerException();
20         } else if (off < 0 || len < 0 || len > b.length - off) {
21             throw new IndexOutOfBoundsException();
22         } else if (len == 0) {
23             return 0;
24         }
25 
26         int c = read();
27         if (c == -1) {
28             return -1;
29         }
30         b[off] = (byte)c;
31 
32         int i = 1;
33         try {
34             for (; i < len ; i++) {
35                 c = read();
36                 if (c == -1) {
37                     break;
38                 }
39                 b[off + i] = (byte)c;
40             }
41         } catch (IOException ee) {
42         }
43         return i;
44     }
45 
46     // 跳过输入流中的n个字节
47     public long skip(long n) throws IOException {
48 
49         long remaining = n;
50         int nr;
51 
52         if (n <= 0) {
53             return 0;
54         }
55 
56         int size = (int)Math.min(MAX_SKIP_BUFFER_SIZE, remaining);
57         byte[] skipBuffer = new byte[size];
58         while (remaining > 0) {
59             nr = read(skipBuffer, 0, (int)Math.min(size, remaining));
60             if (nr < 0) {
61                 break;
62             }
63             remaining -= nr;
64         }
65 
66         return n - remaining;
67     }
68 
69     public int available() throws IOException {
70         return 0;
71     }
72 
73     public void close() throws IOException {}
74 
75     public synchronized void mark(int readlimit) {}
76 
77     public synchronized void reset() throws IOException {
78         throw new IOException("mark/reset not supported");
79     }
80 
81     public boolean markSupported() {
82         return false;
83     }
84 }

  1 package java.io;
  2 
  3 public class ByteArrayInputStream extends InputStream {
  4 
  5     // 保存字节输入流数据的字节数组
  6     protected byte buf[];
  7 
  8     // 下一个会被读取的字节的索引
  9     protected int pos;
 10 
 11     // 标记的索引
 12     protected int mark = 0;
 13 
 14     // 字节流的长度
 15     protected int count;
 16 
 17     // 构造函数：创建一个内容为buf的字节流
 18     public ByteArrayInputStream(byte buf[]) {
 19         // 初始化“字节流对应的字节数组为buf”
 20         this.buf = buf;
 21         // 初始化“下一个要被读取的字节索引号为0”
 22         this.pos = 0;
 23         // 初始化“字节流的长度为buf的长度”
 24         this.count = buf.length;
 25     }
 26 
 27     // 构造函数：创建一个内容为buf的字节流，并且是从offset开始读取数据，读取的长度为length
 28     public ByteArrayInputStream(byte buf[], int offset, int length) {
 29         // 初始化“字节流对应的字节数组为buf”
 30         this.buf = buf;
 31         // 初始化“下一个要被读取的字节索引号为offset”
 32         this.pos = offset;
 33         // 初始化“字节流的长度”
 34         this.count = Math.min(offset + length, buf.length);
 35         // 初始化“标记的字节流读取位置”
 36         this.mark = offset;
 37     }
 38 
 39     // 读取下一个字节
 40     public synchronized int read() {
 41         return (pos < count) ? (buf[pos++] & 0xff) : -1;
 42     }
 43 
 44     // 将“字节流的数据写入到字节数组b中”
 45     // off是“字节数组b的偏移地址”，表示从数组b的off开始写入数据
 46     // len是“写入的字节长度”
 47     public synchronized int read(byte b[], int off, int len) {
 48         if (b == null) {
 49             throw new NullPointerException();
 50         } else if (off < 0 || len < 0 || len > b.length - off) {
 51             throw new IndexOutOfBoundsException();
 52         }
 53 
 54         if (pos >= count) {
 55             return -1;
 56         }
 57 
 58         int avail = count - pos;
 59         if (len > avail) {
 60             len = avail;
 61         }
 62         if (len <= 0) {
 63             return 0;
 64         }
 65         System.arraycopy(buf, pos, b, off, len);
 66         pos += len;
 67         return len;
 68     }
 69 
 70     // 跳过“字节流”中的n个字节。
 71     public synchronized long skip(long n) {
 72         long k = count - pos;
 73         if (n < k) {
 74             k = n < 0 ? 0 : n;
 75         }
 76 
 77         pos += k;
 78         return k;
 79     }
 80 
 81     // “能否读取字节流的下一个字节”
 82     public synchronized int available() {
 83         return count - pos;
 84     }
 85 
 86     // 是否支持“标签”
 87     public boolean markSupported() {
 88         return true;
 89     }
 90 
 91     // 保存当前位置。readAheadLimit在此处没有任何实际意义
 92     public void mark(int readAheadLimit) {
 93         mark = pos;
 94     }
 95 
 96     // 重置“字节流的读取索引”为“mark所标记的位置”
 97     public synchronized void reset() {
 98         pos = mark;
 99     }
100 
101     public void close() throws IOException {
102     }
103 }