系统学习 Java IO (一)—-输入流和输出流 InputStream/OutputStream

目录：系统学习 Java IO —- 目录，概览

InputStream

是Java IO API中所有输入流的父类。
表示有序的字节流，换句话说，可以将 InputStream 中的数据作为有序的字节序列读取。
这在从文件读取数据或者通过网络接收时非常有用。
InputStream 通常连接到某些数据源，如文件，网络连接，管道等
看如下代码片段：

public class InputStreamExample {    public static void main(String[] args) throws IOException {        InputStream inputStream = new FileInputStream("D:\\out.txt");        //do something with data...        int data = inputStream.read();        while (data != -1) {            System.out.print((char) data);            data = inputStream.read();        }        inputStream.close();    }}

注意：为了代码清晰，这里并没有考虑解决异常的情况，IO 异常解决有专门的详情。

read()

此方法返回的是 int 值，其中包含读取的字节的字节值,可以将返回的 int 强制转换为 char 输出。
假如 read() 方法返回 -1 ，则表示已到达流的末尾，这意味着在 InputStream 中不再有要读取的数据。
也就是说，-1 作为 int 值，而不是 -1 作为字节或者短值，这里有区别！

InputStream 类还包含两个 read() 方法，这些方法可以将 InputStream 源中的数据读入字节数组。
这些方法是：

• int read(byte[]);
• int read(byte[], int offset, int length);

一次读取一个字节数比一次读取一个字节要快得多，所以在可以的时候，使用这些读取方法而不是 read() 方法。

read（byte []）方法将尝试将尽可能多的字节读入作为参数给出的字节数组，由于数组具备空间。
该方法返回一个 int ，其值是实际读取了多少字节，这点和 read() 方法不一样。
假如可以从 InputStream 读取的字节少于字节数组的空间，则字节数组的其他部分将包含与读取开始之前相同的数据。例如：

InputStream input = new ByteArrayInputStream("123456789".getBytes());byte[] bytes = new byte[4]; // 每次只读取 4 个字节int data = input.read(bytes);while (data != -1) {      System.out.print(new String(bytes));      data = input.read(bytes);}

将输出 123456789678 ，而不是预期的 123456789 ！

由于第一次读取进 bytes 是 1234 ，第二次将是 5678 ，现在只剩下 9 一个数字了，注意此时 bytes 的值是 5678 ，而后再读取剩下 1个 9，不能装满 bytes 了，只能覆盖 bytes的第一个字节，最后返回的bytes 是 9678。
所以记住检查返回的 int 以查看实际读入字节数组的字节数。

int read(byte[], int offset, int length);方法和 read（byte []）方法差不多，只是添加了偏移量和指定长度。
和 read() 一样，都是返回 -1 表示数据读取结束。
使用实例如下：

InputStream inputstream = new FileInputStream("D://out.txt");byte[] data = new byte[1024];int bytesRead = inputstream.read(data);while(bytesRead != -1) {  doSomethingWithData(data, bytesRead);  bytesRead = inputstream.read(data);}inputstream.close();

首先，此示例创立一个字节数组。
而后它创立一个名为 bytesRead 的 int 变量来保存每次读取 byte [] 调用时读取的字节数，
并立即分配 bytesRead 从第一次读取 byte [] 调用返回的值。

mark() and reset()

InputStream 类有两个名为 mark() 和 reset() 的方法，InputStream 的子类可能支持也可能不支持：

1. 该子类覆盖 markSupported() 并返回true，则支持 mark( )和 reset() 方法。
2. 该子类覆盖 markSupported() 并返回 false ，则不支持 mark() 和 reset() 。
3. 该子类不重写 markSupported() 方法 ，则是父类的默认实现 public boolean markSupported() { return false; } 也是不支持 mark( )和 reset() 方法

mark() 在 InputStream 内部设置一个标记，默认值在位置 0 处。
可以手动标记到目前为止已读取数据的流中的点，而后，代码可以继续从 InputStream 中读取数据。
假如想要返回到设置标记的流中的点，在 InputStream 上调用 reset() ，而后 InputStream “倒退”并返回标记，
如此，便可再次从该mark点开始返回（读取）数据。很显著这可能会导致少量数据从 InputStream 返回屡次。我来举个例子：

 public static void testMarkAndReset() throws IOException {        InputStream input = new ByteArrayInputStream("123456789".getBytes());        System.out.println("第一次打印：");        int count = 0;// 计算是第几次读取，将在第二次读取时做标记；        byte[] bytes = new byte[3]; // 每次只读取 3 个字节        int data = input.read(bytes);        while (data != -1) {            System.out.print(new String(bytes));            if (++count == 2) { // 在第二轮读取，即读到数字 4 的时候，做标记                input.mark(16); // 从 mark 点开始再过 readlimit 个字节，mark 将失效            }            data = input.read(bytes);        }        input.reset();        System.out.println("\n在经过 mark 和 reset 之后从 mark 位置开始打印：");        data = input.read(bytes);        while (data != -1) {            System.out.print(new String(bytes));            data = input.read(bytes);        }    }

将会输出：

第一次打印：123456789在经过 mark 和 reset 之后从 mark 位置开始打印：789  

另外要说明一下 mark(int readlimit) 参数，readlimit 是告诉系统，过了这个 mark 点之后，给本宫记住往后的 readlimit 个字节，由于到时候 reset 之后，要从 mark 点开始读取的；但实际情况和 jdk 文档有出入,很多情况下调用 mark(int readlimit) 方法后，即便读取超过 readlimit 字节的数据，mark 标记仍有效,这又是为什么呢？网上有人解答，但我还是决定亲身探究一番。

我们这个实例引用的实际对象是 ByteArrayInputStream 先看一下它的源码：

/* Note: The readAheadLimit for this class has no meaning.*/    public void mark(int readAheadLimit) {        mark = pos;    }

好家伙，它说这个参数对于这个类没有任何作用。

注意：这段是源码分析可看可不看，跳过不影响阅读

那我们在看看其余的 InputStream 子类，经验证，FileInputStream 和少量实现类不支持 mark() 方法，我们看看 BufferedInputStream类源码：
我先把少量字段的含义说明一下：

• count 索引1大于缓冲区中最后一个有效字节的索引。 该值始终在0到buf.length的范围内; 元素buf [0]到buf [count-1]包含从底层输入流取得的缓冲输入数据。在 read() 方法中读完数据返回 -1 就是由于if (pos >= count) return -1;
• pos 指缓冲区中的当前位置。 这是要从 buf 数组中读取的下一个字符的索引。
  该值始终在 0 到 count 范围内。 假如它小于 count，则 buf [pos] 是要作为输入提供的下一个字节; 假如它等于 count ，则下一个读取或者跳过操作将需要从包含的输入流中读取更多字节。（这句话不了解没关系）
• markpos是调用最后一个 mark() 方法时 pos 字段的值。该值始终在-1到pos的范围内。 假如输入流中没有标记位置，则此字段为-1。

BufferedInputStream 是每次读取肯定量的数据到 buf 数组中的，设置了 readlimit 一定是想让数组从 mark 索引开始至少记录到 (mark + readlimit) 索引。

public synchronized void mark(int readlimit) {        marklimit = readlimit;        markpos = pos;    }public synchronized void reset() throws IOException {        getBufIfOpen(); // Cause exception if closed        if (markpos < 0)            throw new IOException("Resetting to invalid mark");        pos = markpos;    } private void fill() throws IOException {        byte[] buffer = getBufIfOpen();        if (markpos < 0)            pos = 0;            /* 没有标记就直接丢掉缓存，使用buffer取新数据 */        else if (pos >= buffer.length)  /* 缓冲区中当前位置比buffer数组大，才执行下面代码 */            if (markpos > 0) {  /* 可以把 markpos 左边的数据丢掉 */                int sz = pos - markpos; // 需要缓存的字节长度，从 markpos 开始                System.arraycopy(buffer, markpos, buffer, 0, sz); // 复用内存空间                pos = sz;                markpos = 0;            } else if (buffer.length >= marklimit) { // 假如 buffer 的长度已经大于 marklimit                markpos = -1;   /* 那 mark 就失效了*/                pos = 0;        /* 删除buffer内容，取新数据 */            } else if (buffer.length >= MAX_BUFFER_SIZE) { // 假如buffer过长就抛错                throw new OutOfMemoryError("Required array size too large");            } else {            /* buffer 还没 marklimit 大，扩容到 pos 的2倍或者者最大值 */                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)) {                    throw new IOException("Stream closed");                }                buffer = nbuf;            }        count = pos;        int n = getInIfOpen().read(buffer, pos, buffer.length - pos);        if (n > 0)            count = n + pos;    }

可以得出：设置标记后，

1. 假如缓冲区中当前位置比 buffer 数组小，也就是还没读完 buffer 数组，那 mark 标记不会失效；
2. 下次继续读取，超过 buffer 大小字节后，判断 markpos 能否大于0，假如 markpos 大于0，即还在 buffer 数组内，则把 markpos 左边的数据清理，markpos 指向 0 , 复用内存空间，并设置 buffer 的大小为 (pos – markpos) 的值；
3. 再继续读取，此时 markpos 一定不在 buffer 数组包含范围了，此时判断 buffer 的长度能否大于等于
   marklimit ，假如小于 marklimit ，那说明设置 mark 后读取的数据长度还没达到要求的 marklimit 了，给我继续，保持从 mark 点开始缓存, mark 标记不会失效。而后 buffer 就扩容到Math.min(2倍 pos 或者最大值 ，marklimit)；
4. 再继续读取，同上，buffer 这么努力扩容，总有大于 marklimit 的时候，这时说明设置 mark 后继续读取的数据长度已经超过要求的 marklimit 了，仁尽义至，标记失效；

我们就只分析了 ByteArrayInputStream 和 BufferedInputSteam 类的算法，其它输入流不知道。因而 mark() 方法标记时，务必考虑好 readlimit 的值。

OutputStream

OutputStream通常始终连接到某个数据目标，如文件，网络连接，管道等。 OutputStream的数据目标是写入OutputStream的所有数据最终结束的地方。

write(byte)

write(byte)方法用于将单个字节写入 OutputStream。 OutputStream 的 write() 方法接受一个 int ，其中包含要写入的字节的字节值。 只写入 int 值的第一个字节。 其他的被忽略了。
OutputStream 的子类可以有替代的 write() 方法。 例如，DataOutputStream允许您使用相应的方法writeBoolean()，writeDouble() 等编写诸如 int，long，float，double，boolean 等 Java 类型。

write(byte[] bytes) ， write(byte[] bytes, int offset, int length)

和 InputStream 一样，它们也可以将一个数组或者一部分字节写入 OutputStream 。

flush()

OutputStream 的flush() 方法将写入 OutputStream 的所有数据刷新究竟层数据目标。 例如，假如 OutputStream 是 FileOutputStream ，则写入 FileOutputStream 的字节可能尚未完全写入磁盘。 即便您的Java代码已将其写入 FileOutputStream ，数据也可能在某处缓存在内存中。 通过调用 flush() ，您可以确保将任何缓冲的数据刷新（写入）到磁盘（或者网络，或者 OutputStream 的目标所具备的任何其余内容）。