java IO相关API探索之Closeable和InputStream接口

<span style="font-family:Comic Sans MS;font-size:18px;">import java.io.IOException;

/**
 * A {@code Closeable} is a source or destination of data that can be closed.
 * The close method is invoked to release resources that the object is
 * holding (such as open files).
 *
 * @since 1.5
 */
public interface Closeable extends AutoCloseable {

    /**
     * Closes this stream and releases any system resources associated
     * with it. If the stream is already closed then invoking this
     * method has no effect.
     *
     * <p> As noted in {@link AutoCloseable#close()}, cases where the
     * close may fail require careful attention. It is strongly advised
     * to relinquish the underlying resources and to internally
     * <em>mark</em> the {@code Closeable} as closed, prior to throwing
     * the {@code IOException}.
     *
     * @throws IOException if an I/O error occurs
     */
    public void close() throws IOException;
}</span>

<span style="font-family:Comic Sans MS;font-size:18px;">接口Closeable继承自AutoCloseable，同时重写了关于 close关闭流的方法。Closeable 是一个能够被关闭的数据源，close方法被调用区释放对象持有的资源例如打开的文件。</span>

关闭stream流和与之相关的资源，如果流已经关闭了，那么再次调用这个方法是没有影响的。与AutoCloseable中的close方法一样，如果关闭操作失败，那么就要格外注意了。
当IO异常发生时该方法会抛出IOExce异常

上面主要是关于Closeable的介绍，而InputStream则是Closeable的一个实现，而InputStream是一个抽象类，所谓抽象类就是该类不能被实例化，只能实例化它的非抽象子类，我看的是jdk1.8的实现。

public abstract class InputStream implements Closeable

MAX_SKIP_BUFFER_SIZE is used to determine the maximum buffer size to

use when skipping.
 private static final int MAX_SKIP_BUFFER_SIZE = 2048;

类中定义了一个static final类型的变量，用来指定InputStream流一次能够跳过的字节的最大值(忽略字节)，后面的一个方法skip会用到这个常量

<span style="font-family:Comic Sans MS;font-size:18px;">public abstract int read() throws IOException;</span>

这个read方法待实现，主要是从流中读取一个字节作为输出，Reads the next byte of data from the input stream，因为0-255能够表示所有的字节，所以如果read方法返回-1，则说明这个流已经到了末尾。则不再读取即可.在while中直接break就OK了。

<span style="font-family:Comic Sans MS;font-size:18px;">public int read(byte b[]) throws IOException {
        return read(b, 0, b.length);
}</span>

read(byte b[])方法读取流中的b.length个字节到字节数组b[]中。返回值表示读取到字节数组中的字节数。下面我们看一下关于read(b, 0, b.length)方法怎么实现的。

<span style="font-family:Comic Sans MS;font-size:18px;">public int read(byte b[], int off, int len) throws IOException {
        if (b == null) {
            throw new NullPointerException();
        } else if (off < 0 || len < 0 || len > b.length - off) {
            throw new IndexOutOfBoundsException();
        } else if (len == 0) {
            return 0;
        }
        int c = read();
        if (c == -1) {
            return -1;
        }
        b[off] = (byte)c;

        int i = 1;
        try {
            for (; i < len ; i++) {
                c = read();
                if (c == -1) {
                    break;
                }
                b[off + i] = (byte)c;
            }
        } catch (IOException ee) {
        }
        return i;
    }</span>

(off表示开始位置，len表示读取流的最长字节)如果b字节数组为null的话，则会抛出空指针异常，如果开始位置off 小于0或者len小于0或者len > b.length - off(表示从开头off + 要读取的字节长度 len) 大于字节数组的length，则抛出数组越界异常。

如果len == 0，那么则直接返回0，表示读入到字节数组中的字节数为0；向后读取一个字节，如果返回为-1，则表示已经到达流的末尾，返回-1即可。b[off] = (byte)c;从这句代码就可以知道read(b, off, len)是把文件流读入到b字节数组中，读入数组中的位置从off索引开始，并且最长能够读取的就是填到b的末尾了，但是由于是从字节的off索引开始填充的，所以最长只能够读取b.length - off个字节。后面一个for循环，一个字节一个字节的读入到字节数组中off+i索引的位置。如果读到-1，那么跳出循环，返回读入到数组中的字节个数。

下面这个方法就是用到了最开始定义的最长能够跳过的字节数

<span style="font-family:Comic Sans MS;font-size:18px;">public long skip(long n) throws IOException {

        long remaining = n;
        int nr;

        if (n <= 0) {
            return 0;
        }

        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 -= nr;
        }

        return n - remaining;
    }</span>

跳过Math.min(MAX_SKIP_BUFFER_SIZE, remaining),这么长的字节，所谓的跳过，就是把这么多字节读入到另外一个不处理的字节数组中，然后函数结束的时候会自动释放，这样就跳过了一些流中的字节。比如要跳过3000字节，那么在调用Math.min方法的时候就会设置size=2048，然后调用read方法把2048个字节读入到skipBuffer字节数组中，假设文件流中只剩下了1000个字节，那么根据上面的方法介绍，则第一次进入while循环时，nr=1000，remaining=3000-1000=2000,因为n=3000，所以该函数返回3000-2000=1000，所以该函数返回的数据是跳过的字节数。

<span style="font-family:Comic Sans MS;font-size:18px;">public int available() throws IOException {
        return 0;
}</span>

代码中是这么解释返回值的：返回一个可能被读取的流中的字节数或者能够跳过的流中字节数，该方法要其子类来实现，其实就是返回流中的字节数.

<span style="font-family:Comic Sans MS;font-size:18px;">public void close() throws IOException {}</span>

这个方法就不用多说了，关闭文件流操作，不过具体实现要待子类中实现了 。

publicsynchronizedvoid mark(intreadlimit) {}

同步操作，mark就像书签一样，在这个BufferedReader对应的buffer里作个标记，以后再调用reset时就可以再回到这个mark过的地方。mark方法有个参数，通过这个整型参数，你告诉系统，希望在读出这么多个字符之前，这个mark保持有效。读过这么多字符之后，系统可以使mark不再有效，而你不能觉得奇怪或怪罪它。这跟buffer有关，如果你需要很长的距离，那么系统就必须分配很大的buffer来保持你的mark。       
    //reader       is       a       BufferedReader     
    reader.mark(50);//要求在50个字符之内，这个mark应该保持有效，系统会保证buffer至少可以存储50个字符     
    int       a       =       reader.read();//读了一个字符     
    int       b       =       reader.read();//又读了一个字符     
    //做了某些处理，发现需要再读一次     
    reader.reset();     
    reader.read();//读到的字符和a相同     
    reader.read();//读到的字符和b相同
对应的使用reset则使得文件流指针又指向了原来mark的位置，读取相同数据

<span style="font-family:Comic Sans MS;font-size:18px;">public synchronized void reset() throws IOException {
        throw new IOException("mark/reset not supported");
}</span>

该方法待子类实现。这里只抛出了不支持mark或者reset方法。

<span style="font-family:Comic Sans MS;font-size:18px;">public boolean markSupported() {
        return false;
    }</span>

测试这个文件流是否支持mark以及reset方法。

下面是测试代码：

<span style="font-family:Comic Sans MS;">// TODO Auto-generated method stub
		//文件中的内容为：helloworld
		File file = new File("/users/terrylmay/desktop/test.txt");
		FileInputStream fis = new FileInputStream(file);
		BufferedInputStream br = new BufferedInputStream(fis);
		//br.skip(2);跳过两个字节，那么流中就只剩下了lloworld
		br.skip(2);
		//设置在读取的5个字节内标识有效，并且标记当前位置
		br.mark(5);
		//读取两个字节a = 'l' b='l'
		int a = br.read();
		int b = br.read();
		//打印
		System.out.println(""+(char)a+(char)b);
		//使得复位
		br.reset();
		//再次读取流中的字节
		a = br.read();
		b = br.read();
		//打印
		System.out.println(""+(char)a+(char)b);
		//返回流中的剩余字节
		int length = br.available();
		System.out.println(length);</span>

打印结果为:

ll

ll

6