文章出自：听云博客
题主将以三个章节的篇幅来讲解JAVA IO的内容 。
第一节JAVA IO包的框架体系和源码分析，第二节，序列化反序列化和IO的设计模块，第三节异步IO。
本文是第一节。
IO框架
从上图我们可以看出IO可以分为两大块 字节流和字符流
字节流是 InputStream 和 OutputStream 分别对应输入与输出
字符流是Reader和Writer分别对应输入与输出
ByteArrayInputStream
它字节数组输入流。继承于InputStream。它包含一个数组实现的缓冲区ByteArrayInputStream也是数组实现的，提供read()来读取数据，内部有一个计数器用来确定下一个要读取的字节。
分析源码
//pos是下一个会被读取字节的索引
//count字节流的长度
//pos为0就是从0开始读取
//读取下一个字节， &0xff的意思是将高8位全部置0
// 将“字节流的数据写入到字节数组b中”
// off是“字节数组b的偏移地址”，表示从数组b的off开始写入数据
// len是“写入的字节长度”
ByteArrayOutputStream
它是字节数组输出流。继承于OutputStream。ByteArrayOutputStream 实际也是数组实现的，它维护一个字节数组缓冲。缓冲区会自动扩容。
源码分析
//我们看到不带参的构造方法默认值是32 数组大小必须大于0否则会报 Negative initial size错误 ByteArrayOutputStream本质是一个byte数组
//是将字节数组buffer写入到输出流中，offset是从buffer中读取数据的起始下标，len是写入的长度。
//ensureCapacity方法是判断数组是否需要扩容
//System.arraycopy是写入的实现
//数组如果已经写满则grow
//int Capacity=oldCapacity<<1，简单粗暴容量X2
Piped(管道)
多线程可以通过管道实现线程中的通讯，在使用管道时必须PipedInputStream，PipedOutputStream配套缺一不可
PipedInputStream
//初始化管道
//链接管道
//将“管道输入流”和“管道输出流”绑定。
//调用的是PipedOutputStream的connect方法
PipedOutputStream
//指定配对的PedpedInputStream
示例
package ioEx;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
import java.io.IOException;
public class PipedStreamEx {
public static void main(String[] args) {
Writer t1 = new Writer();
Reader t2 = new Reader();
//获取输入输出流
PipedOutputStream out = t1.getOutputStream();
PipedInputStream in = t2.getInputStream();
try {
//将管道连接 也可以这样写 out.connect(in);
in.connect(out);
t1.start();
t2.start();
} catch (IOException e) {
e.printStackTrace();
}
}
}
class Reader extends Thread {
private PipedInputStream in = new PipedInputStream();
// 获得“管道输入流”对象
public PipedInputStream getInputStream(){
return in;
}
@Override
public void run(){
readOne() ;
//readWhile() ;
}
public void readOne(){
// 虽然buf的大小是2048个字节，但最多只会从输入流中读取1024个字节。
// 输入流的buffer的默认大小是1024个字节。
byte[] buf = new byte[2048];
try {
System.out.println(new String(buf,0,in.read(buf)));
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
// 从输入流中读取1024个字节
public void readWhile() {
int total=0;
while(true) {
byte[] buf = new byte[1024];
try {
int len = in.read(buf);
total += len;
System.out.println(new String(buf,0,len));
// 若读取的字节总数>1024，则退出循环。
if (total > 1024)
break;
} catch (IOException e) {
e.printStackTrace();
}
}
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
class Writer extends Thread {
private PipedOutputStream out = new PipedOutputStream();
public PipedOutputStream getOutputStream(){
return out;
}
@Override
public void run(){
writeSmall1024();
//writeBigger1024();
}
// 向输出流中写入1024字节以内的数据
private void writeSmall1024() {
String strInfo = "I < 1024" ;
try {
out.write(strInfo.getBytes());
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
// 向“管道输出流”中写入一则较长的消息
private void writeBigger1024() {
StringBuilder sb = new StringBuilder();
for (int i=0; i<103; i++)
sb.append("0123456789");
try {
// sb的长度是1030 将1030个字节写入到输出流中， 测试一次只能读取1024个字节
out.write( sb.toString().getBytes());
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
ObjectInputStream 和 ObjectOutputStream
Object流可以将对象进行序列化操作。ObjectOutputStream可以持久化存储对象, ObjectInputStream，可以读出这些这些对象。
源码很简单直接上例子，关于序列化的内容题主将于下一节叙述
package ioEx;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.Map;
import java.util.Map.Entry;
import java.util.HashMap;
import java.util.Iterator;
public class ObjectStreamTest {
private static final String FILE_NAME= "test.txt";
public static void main(String[] args) {
testWrite();
testRead();
}
private static void testWrite() {
try {
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(FILE_NAME));
out.writeByte((byte)1);
out.writeChar(‘a‘);
out.writeInt(20160329);
out.writeFloat(3.14F);
out.writeDouble(Math.PI);
out.writeBoolean(true);
// 写入HashMap对象
Map<String,String> map = new HashMap<String,String>();
map.put("one", "one");
map.put("two", "two");
map.put("three", "three");
out.writeObject(map);
// 写入自定义的Box对象，Box实现了Serializable接口
Test test = new Test("a", 1, "a");
out.writeObject(test);
out.close();
} catch (Exception ex) {
ex.printStackTrace();
}
}
private static void testRead() {
try {
ObjectInputStream in = new ObjectInputStream(new FileInputStream(FILE_NAME));
System.out.println(in.readBoolean());
System.out.println(in.readByte()&0xff);
System.out.println(in.readChar());
System.out.println(in.readInt());
System.out.println(in.readFloat());
System.out.println(in.readDouble());
Map<String,String> map = (HashMap) in.readObject();
Iterator<Entry<String, String>> iter = map.entrySet().iterator();
while (iter.hasNext()) {
Map.Entry<String, String> entry = (Map.Entry<String, String>)iter.next();
System.out.println(entry.getKey()+":"+ entry.getValue());
}
Test test = (Test) in.readObject();
System.out.println("test: " + test);
in.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
class Test implements Serializable {
private String a;
private int b;
private String c;
public Test(String a, int b, String c) {
this.a = a;
this.b = b;
this.c = c;
}
@Override
public String toString() {
return "a, "+b+", c";
}
}
FileInputStream 和 FileOutputStream
FileInputStream 是文件输入流，它继承于InputStream。我们使用FileInputStream从某个文件中获得输入字节。
FileOutputStream 是文件输出流，它继承于OutputStream。我们使用FileOutputStream 将数据写入 File 或 FileDescriptor 的输出流。
File操作十分简单，这里就不再展示示例了。
FilterInputStream
它的作用是用来封装其它的输入流，并为它们提供额外的功能。它的常用的子类有BufferedInputStream和DataInputStream和PrintStream。。
BufferedInputStream的作用就是为“输入流提供缓冲功能，以及mark()和reset()功能”。
DataInputStream 是用来装饰其它输入流，它允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型。应用程序可以使用 DataOutputStream(数据输出流)写入由DataInputStream(数据输入流)读取的数据
(01) BufferedOutputStream的作用就是为“输出流提供缓冲功能”。
(02) DataOutputStream 是用来装饰其它输出流，将DataOutputStream和DataInputStream输入流配合使用，“允许应用程序以与机器无关方式从底层输入流中读写基本 Java 数据类型”。
(03) PrintStream 是用来装饰其它输出流。它能为其他输出流添加了功能，使它们能够方便地打印各种数据值表示形式。
主要了解一下Buffered流
BufferedInputStream
它是缓冲输入流。它继承于FilterInputStream。它的作用是为另一个输入流添加一些功能，例如，提供“缓冲功能”以及支持“mark()标记”和“reset()重置方法”。它本质上是通过一个内部缓冲区数组实现的
源码分析
方法不再一一解读，重点讲两个方法 read1 和 fill
根据fill()中的判断条件可以分为五种情况
情况1：读取完buffer中的数据，并且buffer没有被标记
(01) if (markpos < 0) 它的作用是判断“输入流是否被标记”。若被标记，则markpos大于/等于0；否则markpos等于-1。
(02) 在这种情况下：通过getInIfOpen()获取输入流，然后接着从输入流中读取buffer.length个字节到buffer中。
(03) count = n + pos; 这是根据从输入流中读取的实际数据的多少，来更新buffer中数据的实际大小。
情况2：读取完buffer中的数据，buffer的标记位置>0，并且buffer中没有多余的空间
这种情况发生的情况是 — — 输入流中有很长的数据，我们每次从中读取一部分数据到buffer中进行操作。当我们读取完buffer中的数据之后，并且此时输入流存在标记时；那么，就发生情况2。此时，我们要保留“被标记位置”到“buffer末尾”的数据，然后再从输入流中读取下一部分的数据到buffer中。
其中，判断是否读完buffer中的数据，是通过 if (pos >= count) 来判断的；
判断输入流有没有被标记，是通过 if (markpos < 0) 来判断的。
判断buffer中没有多余的空间，是通过 if (pos >= buffer.length) 来判断的。
理解这个思想之后，我们再对这种情况下的fill()代码进行分析，就特别容易理解了。
(01) int sz = pos - markpos; 作用是“获取‘被标记位置’到‘buffer末尾’”的数据长度。
(02) System.arraycopy(buffer, markpos, buffer, 0, sz); 作用是“将buffer中从markpos开始的数据”拷贝到buffer中(从位置0开始填充，填充长度是sz)。接着，将sz赋值给pos，即pos就是“被标记位置”到“buffer末尾”的数据长度。
(03) int n = getInIfOpen().read(buffer, pos, buffer.length - pos); 从输入流中读取出“buffer.length - pos”的数据，然后填充到buffer中。
(04) 通过第(02)和(03)步组合起来的buffer，就是包含了“原始buffer被标记位置到buffer末尾”的数据，也包含了“从输入流中新读取的数据”。
情况3：读取完buffer中的数据，buffer被标记位置=0，buffer中没有多余的空间，并且buffer.length>=marklimit
执行流程如下，
(01) read() 函数中调用 fill()
(02) fill() 中的 else if (pos >= buffer.length) ...
(03) fill() 中的 else if (buffer.length >= marklimit) ...
说明：这种情况的处理非常简单。首先，就是“取消标记”，即 markpos = -1；然后，设置初始化位置为0，即pos=0；最后，再从输入流中读取下一部分数据到buffer中。
情况4：读取完buffer中的数据，buffer被标记位置=0，buffer中没有多余的空间，并且buffer.length<marklimit
执行流程如下，
(01) read() 函数中调用 fill()
(02) fill() 中的 else if (pos >= buffer.length) ...
(03) fill() 中的 else { int nsz = pos * 2; ... }
这种情况的处理非常简单。
(01) 新建一个字节数组nbuf。nbuf的大小是“pos*2”和“marklimit”中较小的那个数。
(02) 接着，将buffer中的数据拷贝到新数组nbuf中。通过System.arraycopy(buffer, 0, nbuf, 0, pos)
(03) 最后，从输入流读取部分新数据到buffer中。通过getInIfOpen().read(buffer, pos, buffer.length - pos);
注意：在这里，我们思考一个问题，“为什么需要marklimit，它的存在到底有什么意义？”我们结合“情况2”、“情况3”、“情况4”的情况来分析。
假设，marklimit是无限大的，而且我们设置了markpos。当我们从输入流中每读完一部分数据并读取下一部分数据时，都需要保存markpos所标记的数据；这就意味着，我们需要不断执行情况4中的操作，要将buffer的容量扩大……随着读取次数的增多，buffer会越来越大；这会导致我们占据的内存越来越大。所以，我们需要给出一个marklimit；当buffer>=marklimit时，就不再保存markpos的值了。
情况5：除了上面4种情况之外的情况
执行流程如下，
(01) read() 函数中调用 fill()
(02) fill() 中的 count = pos...
这种情况的处理非常简单。直接从输入流读取部分新数据到buffer中。
BufferedOutputStream
BufferedOutputStream 是缓冲输出流。它继承于FilterOutputStream。
BufferedOutputStream 的作用是为另一个输出流提供“缓冲功能”。
代码很简单，就不一一分析了 这里只分析一下write方法
字符流和字符流的区别和使用
字符流的实现与字节流基本相同，最大的区别是字节流是通过byte[]实现的，字符流是通过char[]实现的，这里就不在一一介绍了
按照以下分类我们就可以很清楚的了解在何时使用字节流或字符流
一、按数据源分类：
1 、是文件： FileInputStream, FileOutputStream, ( 字节流 )FileReader, FileWriter( 字符 )
2 、是 byte[] ： ByteArrayInputStream, ByteArrayOutputStream( 字节流 )
3 、是 Char[]: CharArrayReader, CharArrayWriter( 字符流 )
4 、是 String: StringBufferInputStream, StringBufferOuputStream ( 字节流 )StringReader, StringWriter( 字符流 )
5 、网络数据流： InputStream, OutputStream,( 字节流 ) Reader, Writer( 字符流 )
二、按是否格式化输出分：要格式化输出： PrintStream, PrintWriter
三、按是否要缓冲分：要缓冲： BufferedInputStream, BufferedOutputStream,( 字节流 ) BufferedReader, BufferedWriter( 字符流 )
四、按数据格式分：
1 、二进制格式（只要不能确定是纯文本的） : InputStream, OutputStream 及其所有带 Stream 结束的子类
2 、纯文本格式（含纯英文与汉字或其他编码方式）； Reader, Writer 及其所有带 Reader, Writer 的子类
五、按输入输出分：
1 、输入： Reader, InputStream 类型的子类
2 、输出： Writer, OutputStream 类型的子类
六、特殊需要：
1 、从 Stream 到 Reader,Writer 的转换类： InputStreamReader, OutputStreamWriter
2 、对象输入输出： ObjectInputStream, ObjectOutputStream
3 、进程间通信： PipeInputStream, PipeOutputStream, PipeReader, PipeWriter
4 、合并输入： SequenceInputStream
5 、更特殊的需要： PushbackInputStream, PushbackReader, LineNumberInputStream, LineNumberReader
原文链接：http://blog.tingyun.com/web/article/detail/351