Hello, World! 之标准输入流

# InputStream.java

```java
/**
 * This abstract class is the superclass of all classes representing
 * an input stream of bytes.
 *
 * Applications that need to define a subclass of <code>InputStream</code>
 * must always provide a method that returns the next byte of input.
 *
 * @author Arthur van Hoff
 * @see java.io.BufferedInputStream
 * @see java.io.ByteArrayInputStream
 * @see java.io.DataInputStream
 * @see java.io.FilterInputStream
 * @see java.io.InputStream#read()
 * @see java.io.OutputStream
 * @see java.io.PushbackInputStream
 * @since JDK1.0
 */
public abstract class InputStream implements Closeable {
```

从上可以看出 InputStream 类实现了 Closeable 接口，我们再看看 Closeable 接口吧

## Closeable

```java
/**
 * 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.
 *
 * 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
 * mark the {@code Closeable} as closed, prior to throwing
 * the {@code IOException}.
 *
 * @throws IOException if an I/O error occurs
 */
 public void close() throws IOException;
}
```

Closeable 继承自 AutoCloseable，它是可以关闭的数据源或者目标数据，调用这里的 close 方法以释放该对象所持有的资源。close 方法将关闭当前流并释放任何与它关联的系统资源，如果已经关闭，再次调用，没有任何影响。我们再看看 AutoCloseable 吧

## AutoCloseable

```java
/**
 * An object that may hold resources (such as file or socket handles)
 * until it is closed. The {@link #close()} method of an {@code AutoCloseable}
 * object is called automatically when exiting a {@code
 * try}-with-resources block for which the object has been declared in
 * the resource specification header. This construction ensures prompt
 * release, avoiding resource exhaustion exceptions and errors that
 * may otherwise occur.
 *
 * @apiNote
 * It is possible, and in fact common, for a base class to
 * implement AutoCloseable even though not all of its subclasses or
 * instances will hold releasable resources. For code that must operate
 * in complete generality, or when it is known that the {@code AutoCloseable}
 * instance requires resource release, it is recommended to use {@code
 * try}-with-resources constructions. However, when using facilities such as
 * {@link java.util.stream.Stream} that support both I/O-based and
 * non-I/O-based forms, {@code try}-with-resources blocks are in
 * general unnecessary when using non-I/O-based forms.
 *
 * @author Josh Bloch
 * @since 1.7
 */
public interface AutoCloseable {
 /**
 * Closes this resource, relinquishing any underlying resources.
 * This method is invoked automatically on objects managed by the
 * {@code try}-with-resources statement.
 *
 * While this interface method is declared to throw {@code
 * Exception}, implementers are strongly encouraged to
 * declare concrete implementations of the {@code close} method to
 * throw more specific exceptions, or to throw no exception at all
 * if the close operation cannot fail.
 *
 * Cases where the close operation may fail require careful
 * attention by implementers. It is strongly advised to relinquish
 * the underlying resources and to internally mark the
 * resource as closed, prior to throwing the exception. The {@code
 * close} method is unlikely to be invoked more than once and so
 * this ensures that the resources are released in a timely manner.
 * Furthermore it reduces problems that could arise when the resource
 * wraps, or is wrapped, by another resource.
 *
 * Implementers of this interface are also strongly advised
 * to not have the {@code close} method throw {@link
 * InterruptedException}.
 *
 * This exception interacts with a thread's interrupted status,
 * and runtime misbehavior is likely to occur if an {@code
 * InterruptedException} is {@linkplain Throwable#addSuppressed
 * suppressed}.
 *
 * More generally, if it would cause problems for an
 * exception to be suppressed, the {@code AutoCloseable.close}
 * method should not throw it.
 *
 * Note that unlike the {@link java.io.Closeable#close close}
 * method of {@link java.io.Closeable}, this {@code close} method
 * is not required to be idempotent. In other words,
 * calling this {@code close} method more than once may have some
 * visible side effect, unlike {@code Closeable.close} which is
 * required to have no effect if called more than once.
 *
 * However, implementers of this interface are strongly encouraged
 * to make their {@code close} methods idempotent.
 *
 * @throws Exception if this resource cannot be closed
 */
 void close() throws Exception;
}
```

如果有 try}-with-resources block 那么 AutoCloseable 对象会自动关闭。

现在回过头来，继续看 InputStream，它主要有这么几个方法：

```java
public int available() throws IOException {
        return 0;
}

public synchronized void mark(int readlimit) {}

public boolean markSupported() {
    return false;
}

public abstract int read() throws IOException;

public int read(byte b[]) throws IOException {
    return read(b, 0, b.length);
}

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

public synchronized void reset() throws IOException {
    throw new IOException("mark/reset not supported");
}

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

public void close() throws IOException {}
```

Hello, World! 之 标准输入流

Hello, World! 之标准输入流