Java字节流：InputStream OutputStream

字节输入流：InputStream 

类声明：

public abstract class InputStream implements Closeable

位于java.io包下,是一个抽象类.

官方对其说明：
　　This abstract class is the superclass of all classes representing an input stream of bytes.
　　(简单翻译：抽象类InputStream是所有字节输入流的父类)

主要方法：
　　- int available();返回输入流中可读取的字符个数.
　　- void close(): 关闭此输入流并释放与该流有关的系统资源.
　　- void mark(int readlimit): 在此输入流中标记当前的位置.
　　- boolean markSupported(): 检测此输入流是否支持mark和reset.
　　- abstract int read(): 从输入流中读取数据的下一个字节.
　　- int read(byte[] b): 从输入流中读取一定数量的字节,并将其存储在字节数组b中
　　- int read(byte[] b,int off,int len): 从输入流中读取len个字节，并将其存储在字节数组b中off位置开始的地方
　　- void reset(): 将此流重新定位到最后一次对此输入流调用mark方法时的位置.
　　- long skip(long n): 跳过和丢弃此输入流中n个字节的数据.

　　InputStream 是所有字节输入流的父类，其中有一个抽象方法read() 是字节输入流的核心，所有子类都必须实现此方法。
InputStream源代码分析:

package java.io;

/**
 * 该抽象类是所有字节输入流的父类
 */
public abstract class InputStream implements Closeable {

    private static final int MAX_SKIP_BUFFER_SIZE = 2048;//最大允许跳过的字节个数


/*
    功能: 从输入流中读取下一个字节数据,字节数据的值以0-255之间的int类型返回,如果已经到达流末尾，则返回值-1.
        子类必须提供该方法的一个实现.
    返回值:下一个字节数据;如果到达流的末尾则返回-1
*/
    public abstract int read() throws IOException;


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

/*
    功能:从输入流中读取len个字节数据，并把这些字节数据写到字节数组b中（从off位置开始写）
    参数:
        byte b[]: 存储从输入流中读取的字节数据
        int off: 开始位置
        int len: 读取的字节个数
    返回值: 实际从输入流中读取到字节数组b中的字节个数
*/
    public int read(byte b[], int off, int len) throws IOException {

    //检查字节数组b是否为null,检查off len 等参数是否数组越界
        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;

    //循环从输入流中读取len个字节数据到字节数组b中（如果循环读取过程中到达了输入流的末尾，则跳出循环不再读取）
        int i = 1;
        try {
            for (; i < len ; i++) {
                c = read();
                if (c == -1) {
                    break;
                }
                b[off + i] = (byte)c;
            }
        } catch (IOException ee) {
        }
        return i;
    }


/*
    功能: 在输入流中跳过n个字节数据
*/
    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 int available() throws IOException {
        return 0;
    }

/*
    功能: 关闭输入流
*/
    public void close() throws IOException {}

/*
    功能: 在输入流中标记一个位置
*/
    public synchronized void mark(int readlimit) {}

/*
    功能: 将此流重新定位到最后一次对此输入流调用 mark 方法时的位置.
*/
    public synchronized void reset() throws IOException {
        throw new IOException("mark/reset not supported");
    }

/*
    功能: 检查该输入流是否支持mark()和reset()方法
*/
    public boolean markSupported() {
        return false;
    }
}

字节输入流：OutputStream 

类声明：

public abstract class OutputStream implements Closeable

位于java.io包下,是一个抽象类.
官方对其说明：
　　This abstract class is the superclass of all classes representing an output stream of bytes.
　　(简单翻译：抽象类OutputStream是所有字节输出流的父类)

主要方法：
　　- void close(): 关闭此输出流并释放与该流有关的系统资源.
　　- void flush(): 刷新此输出流并强制写出所有缓冲的输出字节.
　　- void write(byte[] b): 将b.length个字节从指定的byte数组写入此输出流.
　　- void write(byte[] b,int off,int len): 将byte数组中从off位置开始的len个字节写入此输出流.
　　- abstract void write(int b): 将指定的字节写入此输出流.

　　OutputStream 是所有字节输出流的父类，其中有一个抽象方法write(int b) 是字节输出流的核心，所有子类都必须实现此方法。

OutputStream源代码分析:

package java.io;

/*
该抽象类是所有字节输出流的父类。输出流接收输出字节并将这些字节发送到某个接收器。
*/
public abstract class OutputStream implements Closeable, Flushable {

/*
    功能: 将指定的数据b写入到输出流中.
*/
    public abstract void write(int b) throws IOException;

/*
    功能:将字节数组b中的全部数据写入到此输出流中
*/
    public void write(byte b[]) throws IOException {
        write(b, 0, b.length);
    }

/*
    功能: 将指定 byte 数组中从偏移量 off 开始的 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]);
        }
    }

/*
    功能:刷新此输出流并强制写出所缓冲的输出字节
*/
    public void flush() throws IOException {
    }

/*
    功能:关闭此输出流并释放与此流关的所系统资源
*/
    public void close() throws IOException {
    }
}