1.流的分类

(1)输入输出流
输入输出是针对程序运行的内存而言的
输入流的基类：InputStream，Reader
输出流的基类：OutputStream, Write

(2)字节流和字符流
用法几乎一样，只是字节流和字符流所操作的数据单元不同，字节流操作的数据单元是8位的 字节，而字符流操作的数据单位是16为 字符

字节流和字符流的处理方式很像，最大的区别只是处理的单位数据量不同

注：一个字符(char)是2个字节，一个字节是8位.

(3)节点流和处理流
节点流是程序直接到实际的数据源进行读写操作，节点流又被称为低级流，如FileInputStream，ByteArrayInputStream

处理流是用一个已存在的流(即节点流？)进行连接或封装，程序通过该封装的流来个实际数据源进行读写操作，换言之，程序不和实际的数据源直接连接。这样可以增强代码的通用性，

注： 1.java中用处理流包装节点流是一种典型的装饰器设计模式，这样通过使用处理流来包装不同的节点流，既可以消除不同节点流的实现差异(即代码编写的差异)，也可以提供更方便的方法来完成输入输出功能，因此处理流也被称为包装流

2.数据源可能是磁盘、硬盘、网络等，而不同的数据源，其代码的编写是有差异的，如果将这些节点流包装成处理流，就可以使用相同的输入输出代码来读写不同设备的数据。

3.处理流的优点: (1)性能提高: 主要以增加缓冲的方式来提高输入/输出的效率;(2)操作便捷： 可以大批量的处理数据。

处理可以 嫁接 到任何已存在的流的基础之上，这样就可以是的Java应用程序采用相同的代码，透明的方式来访问不同的输入输出设备的数据流。

2.字节流和字符流

字节流操作的数数据单元是 字节
字符流操作的数据单元是 字符(2个字节)

(1)InputStream和Reader
InputStream和Reader是所有输入流的抽象基类，是所有输入流的模板。
InputStream里包含的方法：
int read(); //一次从输入流中读取单个字节的数据，返回所读取的字节数据(已转换为int类型了)
int read(byte[] b); //一次最多读取b.length个字节的数据，并将其存储在byte数组中，并返回实际读取的字节个数。这个byte[]就相当于一个取水的竹筒，用他去取水，当然这个竹筒里会有水了啊，并且当水源不够的时候这个竹筒并不能装满。方法返回这个竹筒里实际装的水量
int read(byte[] b, int off, int len); //读取len个字节数据，并将这些数据存储在byte数组b中，但是放入的时候是从数组的off位置开始放入的，方法返回实际读取到的字节数
long skip(long n);//跳过并丢弃该输入流中的n字节数据后，才准备开始写入数据
void close(); //关闭IO资源

Reader里的方法
int read(); //一次从输入流中读取单个字符，返回所读取的字符数据(已转换为了int类型了)
int read(char[] cbuf); //一次最多读取cbuf.length个字符的数据，将读取到的数据存储到char数组中，并返回实际读取到的字符个数
int read(char[] cbuf, int off, int len); //最多读取len个字符数据，并将读取到的数据存储到char数组中，从off位置开始存储，返回实际读取到的字符个数
void close(); //关闭IO资源

注：1.上面的read(Xxx[] b)方法返回-1时，表明数据已经取完了
2.当没有数据的时候，read()也会返回-1
3.直接将byte[]和char[]数组转换为字符串
byte[] -> public String(byte[] bytes, int index, int length);
char[] -> public String(char[] chs, int index, int length);
4.注意数组长度的选取，如果太短，容易造成读取中文字符(2个字节)时出现乱码
5.用完IO流后应该关闭其资源，因为这些IO资源不属于内存里的，故垃圾回收机制无法回收这些资源，因此需要手动关闭。Java7以后增加了自动关闭IO资源的机制，即只要处于try块中的IO流在使用完毕后会自动关闭

(2)OutputStream和Write
OutputStream和Write是所有输出流的抽象基类，是所有输出流的模板。二者的用法完全一样
OutputStream的方法
void write(int b); //将指定的字节(这里以int类型的形式表示该字节)输出到输出流中。
void write(byte[] b); //将一组字节输出到输出流中
void write(byte[] b, int off, int len); //将一组字节从off位置开始，长度为len的字节输出到输出流中
void close()
void flush()

Write的方法
void write(int c); //将指定的字符(这里以int类型的形式表示该字符)输出到输出流中。
void write(char[] cbuf);
void write(char[] cbuf, int off, int len)
abstract void close(); //执行这个方法前，系统会自动执行flush()方法，
abstract void flush(); //刷新缓冲区，将缓冲区中的数据刷新到物理节点中。

//因为字符流直接以字符作为操作单位，所以可以使用字符串来替代字符数组，因此，多了下面两个方法
void write(String str)
void write(String str, int off, int len)

注意：
1.使用完输出流后，切记一定要将IO流资源关闭，不仅可以保正资源被回收外，更重要的是可以将输出缓冲区的数据flush到物理结点中。
2.输出换行符时，不同的平台不一样，如Windows是\r\n, 而在UNIX/LINUX中\n

3.输入输出体系

节点流(如FileInputStream, FileOutputStream)使用起来很繁琐，因此为了简化程序的编写，包装出了处理流。

使用处理流的典型思路：使用处理流来包装节点流，让程序通过处理流来执行输入输出的功能，而节点流只需负责与底层的I/O设备、文件交互。

从名称上来识别处理流和节点流：只要流的构造器参数不是一个物理节点(如stringPath, File等)，而是一个已经存在的流(如OutputStream),那么该流就一定是处理流，而所有的节点流的构造器都是以物理IO节点作为参数。

使用处理流很简单，只需给该处理流传入一个节点流作为构造器参数即可，这样创建的处理流就是包装了该节点流的处理流。

注意：
1.使用处理流时，只需关闭最上层的处理流即可，底层的节点流会自动关闭
2.如果输出输入的内容是文本时，应该采用字符流(更高效)，如果进行输入输出是二进制内容时，则应该采使用字节流
3.Windows下简体中文默认的使用GBK字符集，Linux下默认是UTF-8字符集

4.几个重要的输入输出流

(1)FileInputStream和FileOutputStream、FileReader和FileWrite

前面讲过

(2)BufferedInputStream和BufferedOutputStream、BufferedReader和BufferedWriter

BufferedInputStream
BufferedInputStream(InputStream in);
BufferedInputStream(InputStream in, int size)
int read()
int read(byte[] b, int off, int len)

BufferedOutputStream
BufferedOutputStream(OutputStream out);
BufferedOutputStream(OutputStream out, int size)
void write(byte[] b, int off, int len)
void write(int b)

BufferedReader
BufferedReader(Reader in);
BufferedReader(Reader in, int sz)
int read();
int read(char[] cbuf, int off, int len)
String readLine(); //一次读取一行,没有数据可读时会返回null

例子

BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(a.java)));
String line;
while(line = br.readLine() != null) {
    System.out.println(line);
}

BufferedWriter
BufferedWriter(Writer out);
BufferedWriter(Writer out, int sz)
void write(char[] cbuf, int off, int len)
void write(int c)
void write(String s, int off, int len)
void newLine(); //根据系统来决定换行符
void close()
void flush()

注意：这种处理流体现的是一种装饰器设计模式。

(3)InputStreamReader和OutputStreamWrite

将字节流转换为字符流
InputStreamReader
InputStreamReader(InputStream in); //
InputStreamReader(InputStream in, Charset cs); //指定字符集
InputStreamReader(InputStream in, CharsetDecoder dec)
InputStreamReader(InputStream in, String charsetName)
int read()
int read(char[] cbuf, int offset, int length)

OutputStreamWrite
OutputStreamWriter(OutputStream out);
OutputStreamWriter(OutputStream out, Charset cs);
OutputStreamWriter(OutputStream out, CharsetEncoder enc);
OutputStreamWriter(OutputStream out, String charsetName)
void write(char[] cbuf, int off, int len);
void write(int c);
void write(String str, int off, int len);
void close();
void flush();

注意：这两个转换流也是一种处理流，体现的是一种适配器模式

(4)PrintStream和PrintWrite

打印流，即输出流
PrintStream
PrintStream(File file)
PrintStream(OutputStream out)
PrintStream(OutputStream out, boolean autoFlush);

PrintWrite
PrintWriter(File file);
PrintWriter(OutputStream out);
PrintWriter(OutputStream out, boolean autoFlush);

PrintStream的输出功能非常强大，通常如果需要输出文本内容，都应该考虑将输出流包装成PrintStream后进行输出

注：1.常常在处理文本文件时，将InputStream转换为Reader,再进一步包装成BufferedReader。
2.将OutputStream转换为Write,再进一步包装成BufferedWrite。
3.Scanner sc = new Scanner(System.in); System.in的本质是InputStream 转换为 ->
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String str = br.readLine();

4.RandomAccessFile(随机访问文件流)

可以自由访问文件的任意地方，所以，如果是只需访问文件部分内容，而不是从头读到尾，则使用这个是更好的选择。

注意：RandomAccessFile只能读写文件，不能读取其他的IO节点

RandomAccessFile(File file, String mode); //mode是读写模式，'r','rw','rws','rwd'
RandomAccessFile(String name, String mode)
long getFilePointer(); //返回文件记录指针的当前位置
void setLength(long newLength); //设定文件大小
void seek(long pos); //将文件的记录指针定位到pos位置(是相对于开头处的跳跃)，是绝对位移
int skipBytes(int n);//跳过n个字节(是相对于当前位置的跳跃)，是相对位移
读写方法同InputStream，OutputStream

5.对象序列化(Serialize)与反序列化(Deserialize)

对象序列话的目的是为了将对象保存在磁盘(持久存储)或者在网络中直接传输对象，

对象序列化是指将一个Java对象写入IO流中，与此对应的是反序列化从IO流中恢复该Java对象

实现一个对象序列化，则该对象必须实现Serializable(或Externalizable接口)接口，这是个标记接口

利用ObjectOutputStream和ObjectInputStream来实现对象的序列化输出和反序列化输入

ObjectOutputStream(OutputStream out);
void writeObject(Object obj); //将对象序列化后写入输出流中

ObjectInputStream(InputStream in);
Object readObject(); //从输入流中读取对象， 注意类型转换