这几天在做一个读写文件的小工具，顺便就来了解下IO包的源码，将学习心得记录在此，希望能帮到有需要的朋友。Java IO流相关的类，都在IO包中（当然，JDK1.4新引入的NIO在NIO包中，这里暂不讨论），本文主要对其中常见的类分析源码。IO中最重要的是先区分字节和字符，借用网上的一篇博客图，如下，Java中字节为byte，字符为char，占2个字节，保存unicode字符。
一. 类的划分
IO包中的类和接口共87个，可以使用idea编辑器的生成类图查看(IO包上右击，选择Diagrams => show Diagram...)，包中的类大致可以分为两类，字节流和字符流，每种流又分为输入输出，所以有InputStream、OutputStream、Reader、Writer共四种。我将整个包生成继承图，但由于图太大，只截取了InputStream、OutputStream、Reader、Writer四种图。如下：
1. InputStream
从上图可以看到，InputStream抽象类的实现又可以分为两层，第一层包含FileInputStream、ByteArrayInputStream等面向输入源的流，另一层是为方便流操作的FilterInputStream的子类，如BufferedInputStream。
2. Reader
Reader与InputStream都是输入流，不过Reader是字符流，字符以char为单位，InputStream是字节流，以byte为单位。Reader类继承设计与InputStream类似，不过方便字符流操作的BufferedReader并没有归到FilterReader下，同时提供了字节流向字符流的转化类InputStreamReader，并一步到位的提供了FileReader用来读取文本文件。
3. OutputStream和Writer
这两个输出流的设计和Reader相似，并且提供了PrintStream和PrintWriter。PrintWriter 是字符类型的打印输出流，它继承于Writer。它用于向文本输出流打印对象的格式化表示形式。使用它可以向文件中输出格式化数据。
二. 源码解析
这一部分主要对IO包源码的解析，选取了常用的类。
4. InputStream
InputStream抽象类如下：
skip(long)：该方法用于跳过指定的字节数，但不能超过MAX_SKIP_BUFFER_SIZE否则只跳过这个常量的距离，返回int表示跳过的字节数。
read()：源码上的文档注释如下，该方法作用是读取下一个字节，以int的形式返回0到255，如果到达流结尾则返回-1.
read(byte[])：如下图，该方法读入字节到byte数组，返回int代表读取的字节书，若到达结尾则返回-1.
mark(int)：标记当前位置，调用reset()方法时指针回到这个地方，传入的int表示当读取这么多个字节时这个mark失效。
5. FileInputStream
该类大部分方法都是navite方法，操作底层文件
6. BufferedInputStream
BufferedInputStream继承自FilterInputStream，是带缓存的流，类结构图如下：
可以看到，默认的缓存大小是8192(8M)，最大缓存大小是Integer.MAX_VALUE-8。成员变量pos表示当前在byte[]缓冲区的位置，成员变量count表示缓冲区的有效字节大小。
read()方法首先检查是不是读完了缓存区，是的话填充缓存区，如果还是pos >= count，说明到达了输入流的结尾。fill()填充缓存的源码如下，我写了注释：
/**
* Fills the buffer with more data, taking into account
* shuffling and other tricks for dealing with marks.
* Assumes that it is being called by a synchronized method.
* This method also assumes that all data has already been read in,
* hence pos > count.
*/
private void fill() throws IOException {
byte[] buffer = getBufIfOpen();
// 没有mark标记，清空缓存区
if (markpos < 0)
pos = 0; /* no mark: throw away the buffer */
// 有mark标记，并且缓存区已读完
else if (pos >= buffer.length) /* no room left in buffer */
// mark标记不等于0而是大于0，缓存区元素依次前移
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;
// mark标记等于0并且marklimit小于等于缓存区长度，说明mark已失效，清空缓存区，重置mark标记
} else if (buffer.length >= marklimit) {
markpos = -1; /* buffer got too big, invalidate mark */
pos = 0; /* drop buffer contents */
// mark标记等于0并且marklimit大于缓存区长度，同时缓存长度已达到最大值，无法扩充长度了，报OOM
} else if (buffer.length >= MAX_BUFFER_SIZE) {
throw new OutOfMemoryError("Required array size too large");
// mark标记等于0并且marklimit大于缓存区长度，但缓存区长度没达到最大
} else { /* grow buffer */
// 缓存区扩充双倍，否则扩大到最大缓存区
int nsz = (pos <= MAX_BUFFER_SIZE - pos) ?
pos * 2 : MAX_BUFFER_SIZE;
// 重新调整缩小缓存区
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)
count = n + pos;
}
可以看到，如果还没到缓存byte[]的结尾就调用fill()的话，那么将会读出流填充当前位置后面的字节数组。还会结合marklimit和mark标记调整缓存区大小。
来看下都多个字节的方法read(byte[] b, int off, int len)，源码如下：
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;
}
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;
}
}
上面的read1方法源码如下：
private int read1(byte[] b, int off, int len) throws IOException {
int avail = count - pos;
if (avail <= 0) {
/* If the requested length is at least as large as the buffer, and
if there is no mark/reset activity, do not bother to copy the
bytes into the local buffer. In this way buffered streams will
cascade harmlessly. */
if (len >= getBufIfOpen().length && markpos < 0) {
return getInIfOpen().read(b, off, len);
}
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;
}
可以看到，read()方法中循环调用read1()方法，直到将传入的byte[]数组填满或文件结束。而read1()方法只返回缓存区可用的元素，不一定比byte[]数组的长度要长，所以需要read()方法循环读取。
以上，分析到这里，等之后再继续分析Reader源码。