在java.io包中流的操作主要有字节流、字符流两大类，两类都有输入和输出操作。在字节流中输出数据主要使用OutputStream类完成，输入使用的是InputStream类。
在字符流中输出主要是使用Writer类完成，输入主要是使用Reader类完成。
这四个类都是抽象类，使用中需通过子类进行实例化（向上转型），或者直接使用子类进行io操作。
文件操作的字节流 FileOutputStream，FileInputStream。文件操作的字符流 FileWriter，FileReader。
一.字节流
字节流主要操作byte类型数据。
OutputStream是整个IO包中字节输出流的最大父类，定义如下：
public
abstract
class OutputStream
implements Closeable, Flushable
InputStream是整个IO包中字节输入流的最大父类，定义如下：
public
abstract
class InputStream
implements Closeable
1.文件字节输出流
定义如下：
public
class FileOutputStream
extends OutputStream
核心方法：
（1）核心构造方法：从源码分析，构造函数的核心作用对文件执行open操作。
1 public FileOutputStream(File file, boolean append)
2 throws FileNotFoundException 3 { 4 String name = (file != null ? file.getPath() : null); 5 SecurityManager security = System.getSecurityManager(); 6 if (security != null) { 7 security.checkWrite(name); 8 } 9 if (name == null) { 10 throw new NullPointerException(); 11 } 12 if (file.isInvalid()) { 13 throw new FileNotFoundException("Invalid file path"); 14 } 15 this.fd = new FileDescriptor(); 16 fd.attach(this); 17 this.append = append; 18 this.path = name; 19 open(name, append);//继续向下看 20 }
1 private void open(String name, boolean append)
2 throws FileNotFoundException { 3 open0(name, append);//继续 4 }
1 private native void open0(String name, boolean append)
2 throws FileNotFoundException; 3 //到此在往下就是调用native层的open0函数了。
（2）write和writeBytes函数最终调用的也是navite的write和writeBytes函数
1 private native void write(int b, boolean append) throws IOException;
2
3 private native void writeBytes(byte b[], int off, int len, boolean append) 4 throws IOException;
2.文件字节输入流
定义如下：
（1）核心构造方法，从源码分析，构造函数的核心作用对文件执行open操作。
1 public FileInputStream(File file) throws FileNotFoundException {
2 String name = (file != null ? file.getPath() : null); 3 SecurityManager security = System.getSecurityManager(); 4 if (security != null) { 5 security.checkRead(name); 6 } 7 if (name == null) { 8 throw new NullPointerException(); 9 } 10 if (file.isInvalid()) { 11 throw new FileNotFoundException("Invalid file path"); 12 } 13 fd = new FileDescriptor(); 14 fd.attach(this); 15 path = name; 16 open(name);//继续 17 }
1 private void open(String name) throws FileNotFoundException {
2 open0(name); 3 }
1 private native void open0(String name) throws FileNotFoundException;
（2）read和readBytes函数最终调用的也是navite的read0和readBytes函数
1 private native int read0() throws IOException;
2
3 private native int readBytes(byte b[], int off, int len) throws IOException;
二.字符流
程序中一个字符代表两个字节。
Writer是整个IO包中字符输出流的最大父类，定义如下：
public
abstract
class Writer
implements Appendable, Closeable, Flushable
Reader是整个IO包中字符输入流的最大父类，定义如下：
public abstract class Reader implements Readable, Closeable
1.文件字符输出流
定义如下：
public class FileWriter extends OutputStreamWriter // OutputStreamWriter是Writer的子类
（1）源码：
1 public class FileWriter extends OutputStreamWriter {
2
3 public FileWriter(String fileName) throws IOException { 4 super(new FileOutputStream(fileName)); 5 } 6 7 public FileWriter(String fileName, boolean append) throws IOException { 8 super(new FileOutputStream(fileName, append)); 9 } 10 11 public FileWriter(File file) throws IOException { 12 super(new FileOutputStream(file)); 13 } 14 15 public FileWriter(File file, boolean append) throws IOException { 16 super(new FileOutputStream(file, append)); 17 } 18 19 public FileWriter(FileDescriptor fd) { 20 super(new FileOutputStream(fd)); 21 } 22 23 }
可以看到它所有的构造方法调用的都是其父类的构造方法，并且传递一个FileOutputStream类的实例进去。
随便举一个父类构造方法的例子 （其他最终也是调用StreamEncoder.forOutputStreamWriter）
1 public OutputStreamWriter(OutputStream out, Charset cs) {
2 super(out); 3 if (cs == null) 4 throw new NullPointerException("charset"); 5 se = StreamEncoder.forOutputStreamWriter(out, this, cs);//从字符到字节的编码过程，将字符流转换为字节流。 6 }
（2）其write方法是继承其父类OutputStreamWriter的write方法
随便举一个例子（其他最终也是调用se.write）
public void write(String str, int off, int len) throws IOException {
se.write(str, off, len);
}
/*其中se定义如下*/
private final StreamEncoder se;//它由前面介绍的构造函数实例化
2.文件字符输入流
定义如下：
public class FileReader extends InputStreamReader // InputStreamReader 是 Reader的子类
（1）源码
1 public FileReader(String fileName) throws FileNotFoundException {
2 super(new FileInputStream(fileName)); 3 } 4 5 public FileReader(File file) throws FileNotFoundException { 6 super(new FileInputStream(file)); 7 } 8 9 public FileReader(FileDescriptor fd) { 10 super(new FileInputStream(fd)); 11 }
可以看到它所有的构造方法调用的都是其父类的构造方法，并且传递一个FileIntputStream类的实例进去。
随便举一个例子（其他最终调用也是StreamDecoder.forInputStreamReader）
1 public InputStreamReader(InputStream in, String charsetName)
2 throws UnsupportedEncodingException 3 { 4 super(in); 5 if (charsetName == null) 6 throw new NullPointerException("charsetName"); 7 sd = StreamDecoder.forInputStreamReader(in, this, charsetName);//从字节到字符的解码过程，将字节流转换为字符流 8 }
来看一下StreamDecode的源码
1 public class StreamDecoder extends Reader{
2 private static final int MIN_BYTE_BUFFER_SIZE = 32; 3 private static final int DEFAULT_BYTE_BUFFER_SIZE = 8192; 4 private Charset cs; 5 private CharsetDecoder decoder; 6 private ByteBuffer bb; 7 8 // 由上述的 forInputStreamReader方法的参数可知用的是下面这个方法 9 public static StreamDecoder forInputStreamReader(InputStream in,Object lock,String charsetName) throws UnsupportedEncodingException { 10 String csn = charsetName; 11 if (csn == null) // 由于用的是默认编码，会执行这句 12 csn = Charset.defaultCharset().name(); 13 try { 14 if (Charset.isSupported(csn)) // 检测JVM是否支持该编码集 15 16 return new StreamDecoder(in, lock, Charset.forName(csn)); //调用其构造方法实例化一个对象 17 } catch (IllegalCharsetNameException x) { } 18 throw new UnsupportedEncodingException (csn); 19 } 20 21 StreamDecoder(InputStream in, Object lock, Charset cs) { 22 this(in, lock, cs.newDecoder().onMalformedInput(CodingErrorAction 23 .REPLACE).onUnmappableCharacter(CodingErrorAction.REPLACE)); 24 // 额，说明它是在用Charset对象产生CharsetDecoder对象，目的是为了执行另一个构造函数 25 } 26 27 StreamDecoder(InputStream in, Object lock, CharsetDecoder dec) { 28 // CharsetDecoder：是一个引擎，可以将一个字节序列按照特定的字符集转换成一个16位的Unicode序列 29 super(lock); 30 this.cs = dec.charset(); 31 this.decoder = dec; 32 // 下面的代码先不用管，我们这里用不上 33 // This path disabled until direct buffers are faster 34 if (false && in instanceof FileInputStream) { 35 ch = getChannel((FileInputStream)in); 36 if (ch != null) 37 bb = ByteBuffer.allocateDirect(DEFAULT_BYTE_BUFFER_SIZE); 38 } 39 if (ch == null) { 40 this.in = in; 41 this.ch = null; 42 bb = ByteBuffer.allocate(DEFAULT_BYTE_BUFFER_SIZE); 43 } 44 bb.flip(); // So that bb is initially empty 45 } 46 // 调用的就是这个函数吧 47 public int read() throws IOException { 48 return read0(); //额，又是假的；继续看 49 } 50 private int read0() throws IOException { 51 synchronized (lock) { 52 // Return the leftover char, if there is one 53 if (haveLeftoverChar) { 54 haveLeftoverChar = false; 55 return leftoverChar; 56 } 57 // Convert more bytessz 58 char cb[] = new char[2]; //一次读两个字节 59 int n = read(cb, 0, 2); 60 switch (n) { 61 case -1: 62 return -1; 63 case 2: 64 leftoverChar = cb[1]; 65 haveLeftoverChar = true; 66 // FALL THROUGH 67 case 1: 68 return cb[0]; 69 default: 70 assert false : n; 71 return -1; 72 }// end of catch 73 }// end of synchronized 74 } 75 76 }
(2) read操作见上面的源码