这几天在做一个读写文件的小工具，顺便就来了解下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四种图。如下：

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抽象类如下：

InputStream
skip(long)：该方法用于跳过指定的字节数，但不能超过MAX_SKIP_BUFFER_SIZE否则只跳过这个常量的距离，返回int表示跳过的字节数。
read()：源码上的文档注释如下，该方法作用是读取下一个字节，以int的形式返回0到255，如果到达流结尾则返回-1.
read()
read(byte[])：如下图，该方法读入字节到byte数组，返回int代表读取的字节书，若到达结尾则返回-1.
read(byte[])
mark(int)：标记当前位置，调用reset()方法时指针回到这个地方，传入的int表示当读取这么多个字节时这个mark失效。

5. FileInputStream

该类大部分方法都是navite方法，操作底层文件

FileInputStream

6. BufferedInputStream

BufferedInputStream继承自FilterInputStream，是带缓存的流，类结构图如下：

BufferedInputStream

可以看到，默认的缓存大小是8192(8M)，最大缓存大小是Integer.MAX_VALUE-8。成员变量pos表示当前在byte[]缓冲区的位置，成员变量count表示缓冲区的有效字节大小。

read()
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源码。