Java_io体系之InputStream、OutputStream简介、走进源码——03

Java_io体系之InputStream、OutputStream简介、走进源码——03

一：InputStream

1、       InputStream类简介：

InputStream：字节输入流、是所有字节输入流的父类、本身个抽象类、为字节输入流提供一个标准、和基本的方法及简单的实现、子类可以根据自己的特点进行重写和扩

展。InputStream中有一个抽象方法read()、是字节输入流的核心、要求子类必须实现此方法、此方法也是字节输入流的核心方法、

2、       InputStream 方法简介：

A：构造方法

本身是抽象类、无构造方法。

B：一般方法

	int avaliable();查看当前流中可供读取的字节数。
	
	void close();关闭当前流、释放所有与当前流有关的资源。
	
	synchronized void mark(int readlimit);标记当前流的读取的位子。
	
	boolean markSupport();查看当前流是否支持mark。
	
	abstract int read();读取当前流中的下一个字节、并以整数形式返回、若读取到文件结尾则返回-1。
	
	int read(byte[] b);将当前流中的字节读取到字节数组b中、返回实际读取的字节数
	
	int read(byte[] b, int off, int len);将当前流中的len个字节读取到从下标off开始存放的字节数组b中。
	
	synchronized reset();重置当前流的读取位置到最后一次调用mark方法标记的位置。
		
	long skip(long n);跳过（抛弃）当前流中n个字节。返回实际抛弃的字节数。

3、       InputStream源码分析：

/**
 * 所有字节输出流的父抽象类。提供字节输入流所共有的基本的读取方法。
 */
public abstract class InputStream implements Closeable {

    // skipBuffer的大小
    private static final int SKIP_BUFFER_SIZE = 2048;

    // 内置字节缓存数组、用于构建skip方法中临时存放抛弃的字节。
    private static byte[] skipBuffer;

    /**
     * 	抽象的方法 用于读取输入流中的下一个字节、由其实现类去重写。这也是流的关键方法、下面几个方法都是直接或者间接调用read()方法来实现。
     * @return 0 到 255 之间的整数。如果读到流的结尾则返回 -1 。
     */
    public abstract int read() throws IOException;

    /**
     *	从方法实现也可看出、他是不断调用read(byte[] b, 0, b.length)这个方法作为其方法体。
     * @param      作为一个缓存字节数组来存放从流中读取的字节。
     * @return     读取的字节总个数、如果读到结尾、则返回-1.
     */
    public int read(byte b[]) throws IOException {
    	return read(b, 0, b.length);
    }

    /**
     *	不断的调用read()方法来读取流中的字节、存放到  b 中。
     * @param  b 用来存放读取的字节的字节缓存数组、off 从b[off]开始放 、len 放len个
     * @return 返回读取的字节的总个数。
     */
    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;
    }

    /**
     * 返回跳过的字节数的个数。
     * 这里根本就看不出这个方法到底有什么实际的用途、但是当看到后面的子类实现类的方法体就知道了。
     * @param      n   我们想从从输入流中跳过的字节数
     * @return    实际跳过的字节数、因为有可能输入流中没有那么多有效字节被抛弃、此时则会跳过剩余所有字节、返回的字节数也就是跳之前剩余的字节数。
     */
    public long skip(long n) throws IOException {
    	//方法思想：实际抛弃的字节数  = 想要抛弃的字节数  - 剩余需要抛弃的字节数
    	
    	//记录还剩余多少字节要跳过。
		long remaining = n;
		
		//中间变量、记录每次读取的实际字节数
		int nr;
		//初始化默认大小的全局字节数组。
		if (skipBuffer == null)
		    skipBuffer = new byte[SKIP_BUFFER_SIZE];
		//创建临时的用于存放被读取的字节的字节数组、像垃圾桶、回收被跳过的字节、满了之后在读取就清空从新回收。
		byte[] localSkipBuffer = skipBuffer;
			
		if (n <= 0) {
		    return 0;
		}
		//次循环意义在于记录剩余需要抛弃的字节数
		//大条件、如果还有字节需要被跳过、也就是抛弃、没有则结束循环
		while (remaining > 0) {
			//记录此次实际读取的字节数、后面参数的意义在于防止出现IndexOutOfBoundsException异常。
			
		    nr = read(localSkipBuffer, 0,
			      (int) Math.min(SKIP_BUFFER_SIZE, remaining));
		    //如果读到输入流结尾、则结束循环。
		    if (nr < 0) {
		    	break;
		    }
		    //修改记录还要抛弃的字节数的值
		    remaining -= nr;
		}
		//将n减去还剩多少需要被抛弃的值就是实际抛弃的值
		return n - remaining;
    }

    /**
     * 返回输入流中可读取的有效的字节数、若子类提供此功能、则需要重新实现。
     */
    public int available() throws IOException {
    	return 0;
    }

    /**
     * 关闭流、释放所有与此流有关的资源。
     */
    public void close() throws IOException {}

    /**
     * 在输入流中标记当前位置、与reset()结合使用、
     * 若子类不提供此功能则调用此方法没有任何效果。
     * 若子类提供此功能、则需重新实现。
     */
    public synchronized void mark(int readlimit) {}

    /**
     * 与mark(int readlimit)结合使用、将此流定位到最后一次mark的位置、即调用reset之后、程序继续重mark的位置读取字节流。
     * 若子类不支持此方法、调用则会抛出异常、可事先调用下面的markSupported()来查看当前流是否支持此功能。
     */
    public synchronized void reset() throws IOException {
    	throw new IOException("mark/reset not supported");
    }

    /**
     * 查看当前流是否支持mark、默认是false、即如果实现类不重写此方法就意味着其不支持mark。
     */
    public boolean markSupported() {
    	return false;
    }
}

二：OutputStream

1、OutputStream简介：

       OutputStream：字节输出流、同InputStream意义相同、本身是一个抽象类、为所有字节输出流提供一个标准、和一些简单的方法及简单实现。其核心方法是一个抽象方法: write(byte b)要求子类必须实现此方法、不同功能的类对此方法的实现方式不

一样、一般情况下子类要重写其大多数方法、或者新增一些方法、用于满足更多的需要。

2、OutputStream 方法简介：

A：构造方法

本身是抽象类、无构造方法。

B：一般方法

	abstract void write(byte b);将一个字节写入到当前输出流管道中。

	void write(byte[] b);将字节数组b中所有字节写入到当前输出流管道中。

	void write(byte[] b, int off, int len);将字节数组b从下标off开始、len个字节写入当前输出流管道中

	void flush();flush当前流、将当前流中的所有数据冲刷到目的地中。

	void close();关闭当前流、释放与当前流有关的所有资源。

3、OutputStream源码分析：

public abstract class OutputStream implements Closeable, Flushable {
    /**
     *	将一个8位的字节写入到当前字节输出流中。其子类必须重写、实现此方法。
     */
    public abstract void write(int b) throws IOException;

    /**
     * 将字节数组中b.length个字节写入到当前输出流中。此方法相当与write(byte[] b, 0, b.length);因为其内部就是调用下面的方法。
     */
    public void write(byte b[]) throws IOException {
    	write(b, 0, b.length);
    }

    /**
     * 将一个字节数组中从下标off开始、len个字节写入到当前输出流中。不断调用write来实现的。
     */
    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 {}
}

更多IO内容：java_io 体系之目录