JDK 1.7 java.io 源码学习之InputStream和OutputStream

InputStream和OutputStream是Java IO API 中所有字节输入/输出流的基类，是一个抽象类，实现了Cloaseable接口

InputStream 最核心的是三个read方法：

public abstract int read() throws IOException;
public int read(byte b[]) throws IOException;
public int read(byte b[], int off, int len) throws IOException;

第一个是抽象的read方法是后两个方法的基础，后两个方法均调用了该方法，该方法必须由子类实现。该方法表示一次读取一个字节的数据，如果已经到达流末尾则返回-1

第二个方法等效于第三个方法read(b, 0, b.length)
第三个方法表示一次可以最多读取len个数据字节缓存在byte数组b中，但读取的字节也可能小于该值，以整数的形式返回实际读取的字节数，如果已经到达流末尾则返回-1

public int read(byte b[], int off, int len) throws IOException;

    /*
     * b[]是用于缓冲数据的字节数组
     * len是最大读取的字节数，但读取的字节也可能小于该值
     * off是b[]写入数据时的初始偏移量
     */
    public int read(byte b[], int off, int len) throws IOException {

        if (b == null) {
            // 缓存字节数组 未实例化 抛出NullPointException
            throw new NullPointerException();
        } else if (off < 0 || len < 0 || len > b.length - off) {
            /* off偏移量小于0 
             * 或 最大读取字节数小于0 
             * 或 最大读取字节数超出了b[]数组长度减去偏移长度
             * (即b[]缓冲数组无法保存本次读取的字节数据)
             * 抛出IndexOutOfBoundsException
             */
            throw new IndexOutOfBoundsException();
        } else if (len == 0) {
            //最大读取字节数是0 直接返回0
            return 0;
        }

        // 读取第一个字节的数据
        int c = read();
        // 如果到达流末尾了则直接返回-1, 即该文件是个空文件
        if (c == -1) {
            return -1;
        }

        //将读取的第一个字节数据存入缓冲数组b[off]中
        b[off] = (byte)c;
        /*
         * 将读取的下一个字节数据存入缓冲数据b[off+1]
         * 循环读取下一次字节数据
         * 任何情况下，b[0]-b[off] 和 b[off+len]-b[b.length-1] 都不会受影响
         */
        int i = 1;
        try {
            for (; i < len ; i++) {
                c = read();
                // 若读取到流的末尾, 则结束读取
                if (c == -1) {
                    break;
                }
                //将读取的字节缓冲的缓冲字节数组内
                b[off + i] = (byte)c;
            }
        } catch (IOException ee) {
        }

        // 最终读取的字节数
        return i;
    }

现结合图示演示该方法的执行情况：

FileInputStream fis = new FileInputStream(new File("my.txt"));
byte[] b = "123456789".getBytes();
int off = 0;
int len = 3;
fis.read(b, off, len);
fis.close();
System.out.println(new String(b));

先假设my.txt中的内容如下：

这边UTF-8编码集，一个中文占3个字节，数字和英文以及空格占1个字节
my.txt内文件内容的字节数组示意如上图。

byte[] b 是准备用于缓冲读取的字节数据的字节数组，预先放置了一部分数据，方便于比对前后结果，示意如下图：

现假设off=0，len=3， 即最多读取3个字节的数据缓存在缓冲字节数组0-2下标处，实际结果示意如下图：

缓冲字节数组前三个字节已经被替换为汉字“流”

若off=0，len = 10，则将抛出IndexOutOfBoundsException
因为此时b.length = 9， b.length - off = 9，len > b.length - off ，即缓冲字节数组已经无法缓存一次性读取的字节内容了，放不下

若off=3，len = 3， 则实际结果示意如下图：

因为off = 3， 所以其实保存的数组下标需要进行偏移

同理若off=3，len = 8，则将抛出IndexOutOfBoundsException
因为此时b.length = 9， b.length - off = 6，len > b.length - off ，即缓冲字节数组已经无法缓存一次性读取的字节内容了，放不下

skip 方法

    /**
     * 跳过多少字节的数据内容
     */
    public long skip(long n) throws IOException {
        // 重新保存该变量
        long remaining = n;
        int nr;

        // 如果跳过的字节数小于等于0, 直接返回0
        if (n <= 0) {
            return 0;
        }

        // 跳过的字节数不能超过2048, 取2048 和 传入的跳过字节数的较小值
        int size = (int)Math.min(MAX_SKIP_BUFFER_SIZE, remaining);
        // 根据需要跳过的字节数创建缓存数组
        byte[] skipBuffer = new byte[size];
        while (remaining > 0) {
            // 读取最大的字节数为跳过的字节数的字节内容
            nr = read(skipBuffer, 0, (int)Math.min(size, remaining));
            // 如果已经流末尾则跳出循环
            if (nr < 0) {
                break;
            }
            //改变remaining变量的值, 减去读取返回的字节数, 用于控制循环  
            remaining -= nr;
        }
        //返回实际跳过的字节数
        return n - remaining;
    }

还是结合上述例子，只是中间执行一次skip方法：

FileInputStream fis = new FileInputStream(new File("my.txt"));
byte[] b = "123456789".getBytes();
int off = 0;
int len = 3;
fis.skip(3);
fis.read(b, off, len);
fis.close();
System.out.println(new String(b));

实际结果如下图示意：

因为my.txt 的字节内容，被跳过了3个字节的数据，直接从其第4个字节的数据开始读取了

InputStream还有其他几个扩展方法，后续再具体详述

OutputSteam 对应的则有三个核心的write方法：
public abstract void write(int b) throws IOException;
public void write(byte b[]) throws IOException;
public void write(byte b[], int off, int len) throws IOException;

同理第一个是抽象的write方法是后两个方法的基础，后两个方法均调用了该方法，该方法必须由子类实现。该方法表示一次读取一个字节的数据，如果已经到达流末尾则返回-1

第二个方法等效于第三个方法write(b, 0, b.length)
第三个方法表示一次可以最多写出byte字节数组len的字节

public void write(byte b[], int off, int len) throws IOException {
        if (b == null) {
            throw new NullPointerException();
        } else if ((off < 0) || (off > b.length) || (len < 0) ||
                   ((off + len) > b.length) || ((off + len) < 0)) {
            throw new IndexOutOfBoundsException();
        } else if (len == 0) {
            return;
        }
        //逐个字节写入
        for (int i = 0 ; i < len ; i++) {
            write(b[off + i]);
        }
    }

首先还是一些异常情况的检查判断：
字节数组未实例化、off小于0、off大于字节数组长度、写入流的字节数小于0、off+len 大于字节数组长度、off+len 小于0 等情况

最后循环调用write(int b)，一次一个字节的写入流中

还是结合图示说明：

OutputStream os = new FileOutputStream("my.txt");

String content = "流.write 的常规";

byte[] b = content.getBytes("UTF-8");

os.write(b, 3, 13);

os.flush();
os.close();

实际写入流的是如下内容：

OutputStream 内还有close() 和 flush() 方法，这两个方法具体均需要子类去实现

这两个类暂时 看到这里了。