Java io部分的知识是比较重要的一部分内容，io是理解nio的基础，nio又是理解netty的基础。
相信看到java io体系的结构图的时候都会感叹他的庞大：
在网上查阅相关资料的时候，也没有一个很详细的理解，大部分都是陈列一下api的用法，所以在这里将自己对io的理解记录下来。
InputStream也就是io中的输入流，用来处理字节对象，也叫字节流，他将数据以字节的形式读取到内存中。
InputStream是一个抽象类，最主要的一个方法就是read（）方法，无参就是一个字节一个字节的进行读取数据，使用byte[]作为参数时，则是将读取的字节保存到节数组中。
我们平时接触到的都是他的子类，这里主要通过以下几个类来学习InputStream。
-
FileInputStream
FileInputStream是用于接收文件数据的输入流，他可以读取文件内容到内存中。
看一下它的两个主要的构造方法：
- 入参为文件完整的路径
public FileInputStream(String name) throws FileNotFoundException {
this(name != null ? new File(name) : null);
}
- 入参为File类型
public FileInputStream(File file) throws FileNotFoundException {
String name = (file != null ? file.getPath() : null);
SecurityManager security = System.getSecurityManager();
if (security != null) {
security.checkRead(name);
}
if (name == null) {
throw new NullPointerException();
}
if (file.isInvalid()) {
throw new FileNotFoundException("Invalid file path");
}
fd = new FileDescriptor();
fd.incrementAndGetUseCount();
this.path = name;
open(name);
}
再看下
read（）
：
public int read() throws IOException {
Object traceContext = IoTrace.fileReadBegin(path);
int b = 0;
try {
b = read0();
} finally {
IoTrace.fileReadEnd(traceContext, b == -1 ? 0 : 1);
}
return b;
}
private native int read0() throws IOException;这是无参的read（）,一次读取一个字节，方法返回一个int类型的数据，代表字节对应的ASCLL码。
read(byte[]):
public int read(byte b[]) throws IOException {
Object traceContext = IoTrace.fileReadBegin(path);
int bytesRead = 0;
try {
bytesRead = readBytes(b, 0, b.length);
} finally {
IoTrace.fileReadEnd(traceContext, bytesRead == -1 ? 0 : bytesRead);
}
return bytesRead;
}
private native int readBytes(byte b[], int off, int len) throws IOException;和read（）不同的是这个方法支持传入一个字节数组用来保存读取的字节，也就是说如果你声明了一个new byte[1024],那么每次读取的字节数就将是1024个，他们全都保存在这个字节数组中,同时该方法也会返回一个int，表示实际上读取到的字节数。
了解了上面这些，我们写一个实例来看下效果，随便写一个txt文件，用FileInputStream看看是否可以读取全部内容：
Txt内容：
就放五个字母 abcde来测试下
测试类：
package io;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/**
* 测试inputStream中的read的字节
*/
/**
* @author 18092106
* @create 2018-08-31 15:18
**/
public class TestInputStreamReadMethod {
public void testReadOneByteOnce() {
try(FileInputStream fis = new FileInputStream(new File("E:\\code\\leetcode\\read.txt"))){
int hasRead = 0;
int index = 0;
while ((hasRead = fis.read()) != -1) {
index++;
System.out.println("read()方法第" + index + "次读取的字节是" + hasRead);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
public void testReadBytesOnce(){
try (FileInputStream fis = new FileInputStream(new File("E:\\code\\leetcode\\read.txt"))) {
byte[] bytes = new byte[2];
int hasRead = 0;
int index = 0;
while((hasRead = fis.read(bytes)) != -1){
index++;
System.out.print("read（byte [])第" + index + "次读取读取了" + hasRead + "个字节,byte[]中存放的字节数量是" + bytes.length + "，分别是：");
for (byte b:bytes) {
System.out.print(b + " ");
}
System.out.println();
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
new TestInputStreamReadMethod().testReadOneByteOnce();
new TestInputStreamReadMethod().testReadBytesOnce();
}
}
运行结果：
我们分别测试了两种方式，可以看到read（）一共执行了5次才读取完文件，read（byte[]）中我们用了一个byte[2]来存放数据，一共读了三次，最后一次实际上只读了一个字节，但是byte里面还是有两个字节，这又是为什么呢？
我们用一个图来简单解释下这个过程：
第一次读取a和b,a放入byte[0],b放入byte[1];
第二次读取c和d,c放入byte[0],d放入byte[1];
第三次读取e,e放入byte[0], byte[1]没有修改。
-
ByteArrayInputStream
ByteArrayInputStream从命名就可以看出它是用来接收字节数组类型的数据，他的用法和FileInputStream基本类似。
-
FilterInputStream(装饰器模式)
在java io流的设计中使用到了两种设计模式，这里的FilterInputStream就是用到其中的装饰器模式，我们看下他的源码：
protected FilterInputStream(InputStream in) {
this.in = in;
}
这是它的构造函数，可以接收一个输入流作为参数
再看下read（）方法：
public int read() throws IOException {
return in.read();
}
public int read(byte b[]) throws IOException {
return read(b, 0, b.length);
}
public int read(byte b[], int off, int len) throws IOException {
return in.read(b, off, len);
}
可以看到，它并没有实现任何自己的方法，所有的方法都是调用的构造函数中传入的输入流的方法，真正的实现都在它的子类中，子类继承FilterInputStream，然后重写对应的方法，实现相应的功能，这就是装饰器起到的作用，我们也把这种需要其他节点流作为参数的流叫做处理流。
*装饰器模式：
装饰模式是在不必改变原类文件和使用继承的情况下，动态的扩展一个对象的功能。它是通过创建一个包装对象，也就是装饰来包裹真实的对象。
-
BufferedInputStream
BufferedInputStream就是继承了FilterInputStream的一个处理流，它需要一个节点流作为构造函数的参数才能发挥作用，目的是为了优化原有的节点流，他也被叫做字节缓冲流，我们一起看下BufferedInputStream的源码来学习一下：
构造方法：
public BufferedInputStream(InputStream in) {
this(in, defaultBufferSize);
}
public BufferedInputStream(InputStream in, int size) {
super(in);
if (size <= 0) {
throw new IllegalArgumentException("Buffer size <= 0");
}
buf = new byte[size];
}
可以看到它需要另一个输入流作为参数传入，也就是被装饰的对象，还有一个构造方法提供了一个int类型的参数，我们先放着，后面会介绍。
read(byte[]):
public synchronized int read(byte b[], int off, int len)
throws IOException
{
getBufIfOpen(); // Check for closed stream
if ((off | len | (off + len) | (b.length - (off + len))) < 0) {
throw new IndexOutOfBoundsException();
} else if (len == 0) {
return 0;
}
int n = 0;
for (;;) {
int nread = read1(b, off + n, len - n);
if (nread <= 0)
return (n == 0) ? nread : n;
n += nread;
if (n >= len)
return n;
// if not closed but no bytes available, return
InputStream input = in;
if (input != null && input.available() <= 0)
return n;
}
}
可以看到主要读取的方法是read1()，我们看下read1（）:
private int read1(byte[] b, int off, int len) throws IOException {
int avail = count - pos;
if (avail <= 0) {
/* If the requested length is at least as large as the buffer, and
if there is no mark/reset activity, do not bother to copy the
bytes into the local buffer. In this way buffered streams will
cascade harmlessly. */
if (len >= getBufIfOpen().length && markpos < 0) {
return getInIfOpen().read(b, off, len);
}
fill();
avail = count - pos;
if (avail <= 0) return -1;
}
int cnt = (avail < len) ? avail : len;
System.arraycopy(getBufIfOpen(), pos, b, off, cnt);
pos += cnt;
return cnt;
}
可以看到 这边有一个判断：
if (len >= getBufIfOpen().length && markpos < 0) {我们看下getBuffIfOpen():
private byte[] getBufIfOpen() throws IOException {
byte[] buffer = buf;
if (buffer == null)
throw new IOException("Stream closed");
return buffer;
}
这里面的buf对象就是上面我们第二个构造函数的size构造出来的一个字节数组，如果没有传，那么使用默认的一个值：
private static int defaultBufferSize = 8192;也就是一个大小为8192的字节数据 byte[8192],4K大小，我们继续看刚刚的判断：
if (len >= getBufIfOpen().length && markpos < 0) {这个len就是我们使用BufferedInputStream时自己构造的字节数据的大小，如果我们构造的大小比默认的大了，就使用传入的输入流自身的read(byte[])的方法，如果没有默认的大，那么会调用一个fill()方法：
private void fill() throws IOException {
byte[] buffer = getBufIfOpen();
if (markpos < 0)
pos = 0; /* no mark: throw away the buffer */
else if (pos >= buffer.length) /* no room left in buffer */
if (markpos > 0) { /* can throw away early part of the buffer */
int sz = pos - markpos;
System.arraycopy(buffer, markpos, buffer, 0, sz);
pos = sz;
markpos = 0;
} else if (buffer.length >= marklimit) {
markpos = -1; /* buffer got too big, invalidate mark */
pos = 0; /* drop buffer contents */
} else { /* grow buffer */
int nsz = pos * 2;
if (nsz > marklimit)
nsz = marklimit;
byte nbuf[] = new byte[nsz];
System.arraycopy(buffer, 0, nbuf, 0, pos);
if (!bufUpdater.compareAndSet(this, buffer, nbuf)) {
// Can't replace buf if there was an async close.
// Note: This would need to be changed if fill()
// is ever made accessible to multiple threads.
// But for now, the only way CAS can fail is via close.
// assert buf == null;
throw new IOException("Stream closed");
}
buffer = nbuf;
}
count = pos;
int n = getInIfOpen().read(buffer, pos, buffer.length - pos);
if (n > 0)
count = n + pos;
}
最核心的就是这个：
int n = getInIfOpen().read(buffer, pos, buffer.length - pos);还是调用输入流自身的read(byte[])方法，但是这个字节数据会使用BufferedInputStream中默认的那个，也就是byte[8192],通过这种字节数组作为缓冲区，每次都从这里取数据，不够了就再去取8192个字节数的数据回来。
说了这么多理论，我们还是直接用代码来测试一下，验证一下我们的说法：
package io;
import java.io.*;
/**
* @author 18092106
* @create 2018-08-31 19:11
**/
public class TestBufferedInputStream {
public void useFileInputSream(){
try (FileInputStream fis = new FileInputStream(new File("D:\\安装包\\软件安装包.rar"))) {
byte[] bytes = new byte[1024];
int hasRead;
long startTime = System.currentTimeMillis();
while((hasRead = fis.read(bytes)) != -1){}
long endTime = System.currentTimeMillis();
System.out.println("文件大小1.8G，FileInputStream用时：" + (endTime - startTime));
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
public void useBufferedInputStream(){
try (FileInputStream fis = new FileInputStream(new File("D:\\安装包\\软件安装包.rar"));
BufferedInputStream bis = new BufferedInputStream(fis)) {
byte[] bytes = new byte[1024];
int hasRead;
long startTime = System.currentTimeMillis();
while((hasRead = bis.read(bytes)) != -1){}
long endTime = System.currentTimeMillis();
System.out.println("文件大小1.8G，bufferedInputSream用时：" + (endTime - startTime));
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
new TestBufferedInputStream().useBufferedInputStream();
new TestBufferedInputStream().useFileInputSream();
}
}
运行结果：
我们选择的节点流是FileInputStream，用FileInputStream和BufferedInputStream分别读取一个同一个文件，比较他们的用时。在声明的字节数组大小为1024时，可以明显的看到BufferedInputStream的效率高很多，我们修改下声明的字节数组的大小为8192，也就是BufferedInputStream中默认大小，再来看看结果:
可以看到在这种情况下，反而FileInputStream的效率更高了，这个也和我们看源码得到的结论一致，总结下来就是：
BufferedInputStream内部构造了一个8192大小的字节数组用作缓冲区，如果每次读取的字节数组小于这个默认的，那么就使用这个默认的字节数组来进行i/O访问，通过减少访问次数提高效率，当每次读取的字节数组大于这个默认的时候，还是调用传入的输入流本身的方法，这种情况由于内部的判断等原因，反而输入流的效率会更高。