JAVA SE IO个人小结

Java中的IO流指的是输入输出流，有两种形式：字节流与字符流。

一、字节流

对文件进行输入输出是以字节为单位的。一般的文件读写操作都能用字节流实现。有两个抽象的父类：InputStream、OutputStream。

1、InputStream

InputStream抽象了应用程序读取数据的方式。是一个抽象类，因此不能直接实例化，应该通过继承它的子类进行实例化。

InputStream提供的常用方法有：

public abstract int read() throws IOException;

从输入流中读取数据的下一个字节。返回 0 到 255 范围内的 int 字节值。如果因为已经到达流末尾而没有可用的字节，则返回值-1。在输入数据可用、检测到流末尾或者抛出异常前，此方法一直阻塞。

子类必须提供此方法的一个实现。

返回：

下一个数据字节；如果到达流的末尾，则返回 -1。

抛出：

        IOException - 如果发生 I/O 错误。

 

public int read(byte[] b)throws IOException;

从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。以整数形式返回实际读取的字节数。在输入数据可用、检测到文件末尾或者抛出异常前，此方法一直阻塞。

如果 b 的长度为 0，则不读取任何字节并返回 0；否则，尝试读取至少一个字节。如果因为流位于文件末尾而没有可用的字节，则返回值-1；否则，至少读取一个字节并将其存储在 b 中。

将读取的第一个字节存储在元素 b[0] 中，下一个存储在 b[1] 中，依次类推。读取的字节数最多等于 b 的长度。设 k 为实际读取的字节数；这些字节将存储在 b[0] 到b[k-1] 的元素中，不影响b[k] 到 b[b.length-1] 的元素。

类 InputStream 的 read(b) 方法的效果等同于：

 read(b, 0, b.length)

参数：

b - 存储读入数据的缓冲区。

返回：

读入缓冲区的总字节数；如果因为已经到达流末尾而不再有数据可用，则返回 -1。

抛出：

         IOException - 如果不是因为流位于文件末尾而无法读取第一个字节；如果输入流已关闭；如果发生其他 I/O 错误。

        NullPointerException - 如果b 为 null。

public int read(byte b[],int off,int len)throws IOException;

将输入流中最多 len 个数据字节读入 byte 数组。尝试读取 len 个字节，但读取的字节也可能小于该值。以整数形式返回实际读取的字节数。

在输入数据可用、检测到流末尾或者抛出异常前，此方法一直阻塞。

如果 len 为 0，则不读取任何字节并返回 0；否则，尝试读取至少一个字节。如果因为流位于文件末尾而没有可用的字节，则返回值-1；否则，至少读取一个字节并将其存储在 b 中。

将读取的第一个字节存储在元素 b[off] 中，下一个存储在 b[off+1] 中，依次类推。读取的字节数最多等于len。设 k 为实际读取的字节数；这些字节将存储在 b[off]到 b[off+k-1] 的元素中，不影响b[off+k] 到 b[off+len-1] 的元素。

在任何情况下，b[0] 到 b[off] 的元素以及 b[off+len] 到b[b.length-1] 的元素都不会受到影响。

类 InputStream 的 read(b, off, len) 方法重复调用方法read()。如果第一次这样的调用导致 IOException，则从对 read(b,off, len) 方法的调用中返回该异常。如果对read() 的任何后续调用导致IOException，则捕获该异常并将其视为到达文件末尾；到达该点时读取的字节存储在 b 中，并返回发生异常之前读取的字节数。在已读取输入数据len 的请求数量、检测到文件结束标记、抛出异常前，此方法的默认实现将一直阻塞。建议子类提供此方法更为有效的实现。

参数：

b - 读入数据的缓冲区。

off - 数组 b 中将写入数据的初始偏移量。

len - 要读取的最大字节数。

返回：

读入缓冲区的总字节数；如果因为已到达流末尾而不再有数据可用，则返回 -1。

抛出：

        IOException - 如果不是因为位于文件末尾而无法读取第一个字节；如果输入流已关闭；如果发生其他 I/O 错误。

        NullPointerException - 如果b 为 null。

        IndexOutOfBoundsException - 如果off 为负，len 为负，或者 len 大于 b.length -off

 

public long skip(long n)throws IOException;

跳过和丢弃此输入流中数据的 n 个字节。出于各种原因，skip 方法结束时跳过的字节数可能小于该数，也可能为0。导致这种情况的原因很多，跳过 n 个字节之前已到达文件末尾只是其中一种可能。返回跳过的实际字节数。如果 n 为负，则不跳过任何字节。

此类的 skip 方法创建一个 byte 数组，然后重复将字节读入其中，直到读够 n 个字节或已到达流末尾为止。建议子类提供此方法更为有效的实现。例如，可依赖搜索能力的实现。

参数：

n - 要跳过的字节数。

返回：

跳过的实际字节数。

抛出：

        IOException - 如果流不支持搜索，或者发生其他 I/O 错误。

public int available()throws IOException;

返回此输入流下一个方法调用可以不受阻塞地从此输入流读取（或跳过）的估计字节数。下一个调用可能是同一个线程，也可能是另一个线程。一次读取或跳过此估计数个字节不会受阻塞，但读取或跳过的字节数可能小于该数。

注意，有些 InputStream 的实现将返回流中的字节总数，但也有很多实现不会这样做。试图使用此方法的返回值分配缓冲区，以保存此流所有数据的做法是不正确的。

如果已经调用 close() 方法关闭了此输入流，那么此方法的子类实现可以选择抛出IOException。

类 InputStream 的 available 方法总是返回 0。

此方法应该由子类重写。

返回：

可以不受阻塞地从此输入流读取（或跳过）的估计字节数；如果到达输入流末尾，则返回 0。

抛出：

        IOException - 如果发生 I/O 错误。

 

public void close()throws IOException;

关闭此输入流并释放与该流关联的所有系统资源。

InputStream 的 close 方法不执行任何操作。

抛出：

        IOException - 如果发生 I/O 错误。

2、OutputStream

OutputStream抽象了应用程序写出数据的方式。是一个抽象类，因此不能直接实例化，应该通过继承它的子类进行实例化.

OutputStream提供的常用方法有：

public abstract void write(int b)throws IOException;

将指定的字节写入此输出流。write 的常规协定是：向输出流写入一个字节。要写入的字节是参数 b 的八个低位。b 的 24 个高位将被忽略。

OutputStream 的子类必须提供此方法的实现。

参数：

b - 字节

抛出：

        IOException - 如果发生 I/O 错误。尤其是，如果已关闭输出流，则可能抛出IOException。

public void write(byte[] b)throws IOException;

将 b.length 个字节从指定的 byte 数组写入此输出流。write(b) 的常规协定是：应该与调用write(b, 0, b.length) 的效果完全相同。

参数：

b - 数据。

抛出：

        IOException - 如果发生 I/O 错误。

public void write(byte[] b,int off,int len)throws IOException;

将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。write(b, off, len) 的常规协定是：将数组b 中的某些字节按顺序写入输出流；元素 b[off]是此操作写入的第一个字节，b[off+len-1] 是此操作写入的最后一个字节。

OutputStream 的 write 方法对每个要写出的字节调用一个参数的 write 方法。建议子类重写此方法并提供更有效的实现。

如果 b 为 null，则抛出 NullPointerException。

如果 off 为负，或 len 为负，或者 off+len 大于数组 b 的长度，则抛出 IndexOutOfBoundsException。

参数：

b - 数据。

off - 数据中的初始偏移量。

len - 要写入的字节数。

抛出：

        IOException - 如果发生 I/O 错误。尤其是，如果关闭了输出流，则抛出IOException。

public void flush()throws IOException;

刷新此输出流并强制写出所有缓冲的输出字节。flush 的常规协定是：如果此输出流的实现已经缓冲了以前写入的任何字节，则调用此方法指示应将这些字节立即写入它们预期的目标。

如果此流的预期目标是由基础操作系统提供的一个抽象（如一个文件），则刷新此流只能保证将以前写入到流的字节传递给操作系统进行写入，但不保证能将这些字节实际写入到物理设备（如磁盘驱动器）。

OutputStream 的 flush 方法不执行任何操作。

抛出：

        IOException - 如果发生 I/O 错误。

public void close()throws IOException;

关闭此输出流并释放与此流有关的所有系统资源。close 的常规协定是：该方法将关闭输出流。关闭的流不能执行输出操作，也不能重新打开。

OutputStream 的 close 方法不执行任何操作。

抛出：

        IOException - 如果发生 I/O 错误。

 

这一对抽象类无法实例化，需要通过继承它们的子类来进行实例化。提供的具体子类常用的有：FileInputStream\FileOutputStream、DataInputStream\DataOutputStream、BufferedInputStream\BufferedOutputStream等等。

3、FileInputStream

是InputStream的子类，具体实现了在文件上读取数据的功能，没有做到对功能的拓展。

（1）构造函数

public FileInputStream(String name)throws FileNotFoundException;

通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定。创建一个新FileDescriptor 对象来表示此文件连接。

首先，如果有安全管理器，则用 name 作为参数调用其 checkRead 方法。

如果指定文件不存在，或者它是一个目录，而不是一个常规文件，抑或因为其他某些原因而无法打开进行读取，则抛出FileNotFoundException。

参数：

name - 与系统有关的文件名。

抛出：

        FileNotFoundException - 如果该文件不存在，或者它是一个目录，而不是一个常规文件，抑或因为其他某些原因而无法打开进行读取。

        SecurityException - 如果存在安全管理器，且其checkRead 方法拒绝对文件进行读取访问。

public FileInputStream(File file)throws FileNotFoundException;

通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定。创建一个新FileDescriptor 对象来表示此文件连接。

首先，如果有安全管理器，则用 file 参数表示的路径作为参数调用其checkRead 方法。

如果指定文件不存在，或者它是一个目录，而不是一个常规文件，抑或因为其他某些原因而无法打开进行读取，则抛出FileNotFoundException。

参数：

file - 为了进行读取而打开的文件。

抛出：

FileNotFoundException - 如果该文件不存在，或者它是一个目录，而不是一个常规文件，抑或因为其他某些原因而无法打开进行读取。

SecurityException - 如果存在安全管理器，且其checkRead 方法拒绝对文件进行读取访问。

 

常用方法继承于InputStream。

4、FileOutputStream

       是OutputStream的子类，具体实现了在文件上写数据的功能，没有做到对功能的拓展。

（1）构造函数

*与FileInputStream不同点：当name指示的文件不存在时，系统会先尝试创建该文件，只有当文件无法被创建时，才会抛出异常。

public FileOutputStream(String name)throws FileNotFoundException;

创建一个向具有指定名称的文件中写入数据的输出文件流。创建一个新FileDescriptor 对象来表示此文件连接。

首先，如果有安全管理器，则用 name 作为参数调用 checkWrite 方法。

如果该文件存在，但它是一个目录，而不是一个常规文件；或者该文件不存在，但无法创建它；抑或因为其他某些原因而无法打开它，则抛出FileNotFoundException。

参数：

name - 与系统有关的文件名

抛出：

FileNotFoundException - 如果文件存在，但它是一个目录，而不是一个常规文件；或者该文件不存在，但无法创建它；抑或因为其他某些原因而无法打开它

SecurityException - 如果存在安全管理器，且其checkWrite 方法拒绝对文件进行写入访问。

 

public FileOutputStream(String name, boolean append)throws FileNotFoundException;

创建一个向具有指定 name 的文件中写入数据的输出文件流。如果第二个参数为true，则将字节写入文件末尾处，而不是写入文件开始处。创建一个新 FileDescriptor对象来表示此文件连接。

首先，如果有安全管理器，则用 name 作为参数调用 checkWrite 方法。

如果该文件存在，但它是一个目录，而不是一个常规文件；或者该文件不存在，但无法创建它；抑或因为其他某些原因而无法打开它，则抛出FileNotFoundException。

参数：

name - 与系统有关的文件名

append - 如果为 true，则将字节写入文件末尾处，而不是写入文件开始处

抛出：

         FileNotFoundException - 如果该文件存在，但它是一个目录，而不是一个常规文件；或者该文件不存在，但无法创建它；抑或因为其他某些原因而无法打开它。

         SecurityException - 如果存在安全管理器，且其checkWrite 方法拒绝对文件进行写入访问。

 

public FileOutputStream(File file)throws FileNotFoundException;

创建一个向指定 File 对象表示的文件中写入数据的文件输出流。创建一个新FileDescriptor 对象来表示此文件连接。

首先，如果有安全管理器，则用 file 参数表示的路径作为参数来调用checkWrite 方法。

如果该文件存在，但它是一个目录，而不是一个常规文件；或者该文件不存在，但无法创建它；抑或因为其他某些原因而无法打开，则抛出FileNotFoundException。

参数：

file - 为了进行写入而打开的文件。

抛出：

        FileNotFoundException - 如果该文件存在，但它是一个目录，而不是一个常规文件；或者该文件不存在，但无法创建它；抑或因为其他某些原因而无法打开

        SecurityException - 如果存在安全管理器，且其checkWrite 方法拒绝对文件进行写入访问。

public FileOutputStream(File file,boolean append)throws FileNotFoundException;

创建一个向指定 File 对象表示的文件中写入数据的文件输出流。如果第二个参数为true，则将字节写入文件末尾处，而不是写入文件开始处。创建一个新FileDescriptor 对象来表示此文件连接。

首先，如果有安全管理器，则用 file 参数表示的路径作为参数来调用checkWrite 方法。

如果该文件存在，但它是一个目录，而不是一个常规文件；或者该文件不存在，但无法创建它；抑或因为其他某些原因而无法打开它，则抛出FileNotFoundException。

参数：

file - 为了进行写入而打开的文件。

append - 如果为 true，则将字节写入文件末尾处，而不是写入文件开始处

抛出：

        FileNotFoundException - 如果该文件存在，但它是一个目录，而不是一个常规文件；或者该文件不存在，但无法创建它；抑或因为其他某些原因而无法打开它

        SecurityException - 如果存在安全管理器，且其checkWrite 方法拒绝对文件进行写入访问。

 
其余常用方法继承于OutputStream。

5、DataInputStream

是FilterInputStream的子类，而FilterInputStream是InputStream的子类。DataInputStream对InputStream功能进行初步拓展，将对单字节的读取进行封装，可以更加方便的读取int，long，字符等类型数据。

DataInputStream对于多线程访问不一定安全。 线程安全性是可选的，并且是此类中的方法的用户的责任。

（1）构造函数

public DataInputStream(InputStream in);

构造参数是InputStream类型的，是对InputStream进行包装，拓展其功能。

（2）方法

public final byte readByte()throws IOException;

从所包含的输入流中读取此操作需要的字节。

返回：

此输入流的下一个字节，以有符号 8 位 byte 的形式表示。

抛出：

         EOFException - 如果此输入流已经到达末尾。

         IOException - 该流已关闭并且包含的输入流在关闭后不支持读取操作，或者发生其他 I/O 错误。

 

public final int readUnsignedByte()throws IOException;

从包含的输入流中读取此操作需要的字节。

返回：

此输入流的下一个字节，将它解释为一个无符号 8 位数。

抛出：

        EOFException - 如果此输入流已经到达末尾。

        IOException - 该流已关闭并且包含的输入流在关闭后不支持读取操作，或者发生其他 I/O 错误。

 

public final short readShort()throws IOException;

从包含的输入流中读取此操作需要的字节。

返回：

此输入流的下两个字节，将它们解释为一个有符号 16 位数。

抛出：

        EOFException - 如果此输入流在读取这两个字节之前到达末尾。

        IOException - 该流已关闭并且包含的输入流在关闭后不支持读取操作，或者发生其他 I/O 错误。

public final int readUnsignedShort()throws IOException;

从包含的输入流中读取此操作需要的字节。

返回：

此输入流的下两个字节，将它们解释为一个无符号 16 位整数。

抛出：

        EOFException - 如果此输入流在读取这两个字节之前到达末尾。

        IOException - 该流已关闭并且包含的输入流在关闭后不支持读取操作，或者发生其他 I/O 错误。

public final char readChar()throws IOException;

从包含的输入流中读取此操作需要的字节。

返回：

此输入流的下两个字节，将它们解释为一个 char。

抛出：

        EOFException - 如果此输入流在读取这两个字节之前到达末尾。

        IOException - 该流已关闭并且包含的输入流在关闭后不支持读取操作，或者发生其他 I/O错误。

public final int readInt()throws IOException;

从包含的输入流中读取此操作需要的字节。

返回：

此输入流的下四个字节，将它们解释为一个 int。

抛出：

        EOFException - 如果此输入流在读取这四个字节之前到达末尾。

        IOException - 该流已关闭并且包含的输入流在关闭后不支持读取操作，或者发生其他 I/O 错误。

public final long readLong()throws IOException;

从包含的输入流中读取此操作需要的字节。

返回：

此输入流的下八个字节，将它们解释为一个 long。

抛出：

        EOFException - 如果此输入流在读取这八个字节之前到达末尾。

        IOException - 该流已关闭并且包含的输入流在关闭后不支持读取操作，或者发生其他 I/O 错误。

public final float readFloat()throws IOException;

从包含的输入流中读取此操作需要的字节。

返回：

此输入流的下四个字节，将它们解释为一个 float。

抛出：

        EOFException - 如果此输入流在读取这四个字节之前到达末尾。

        IOException - 该流已关闭并且包含的输入流在关闭后不支持读取操作，或者发生其他 I/O 错误。

public final double readDouble()throws IOException;

从包含的输入流中读取此操作需要的字节。

返回：

此输入流的下八个字节，将它们解释为一个 double。

抛出：

        EOFException - 如果此输入流在读取这八个字节之前到达末尾。

        IOException - 该流已关闭并且包含的输入流在关闭后不支持读取操作，或者发生其他 I/O 错误。

其余功能继承自InputStream。

 

 

6、DataOutputStream

是FilterOutputStream的子类，而FilterOutputStream是OutputStream的子类。DataOutputStream对OutputStream功能进行初步拓展，将对单字节的读取进行封装，可以更加方便的输出int，long，字符等类型数据。

（1）构造函数

public DataOutputStream(OutputStream out);

构造参数为OutputStream类型的，是对OutputStream的封装。

（2）方法

public final void writeByte(int v)throws IOException;

将一个 byte 值以 1-byte 值形式写出到基础输出流中。如果没有抛出异常，则计数器 written 增加1。

参数：

v - 要写入的 byte 值。

抛出：

        IOException - 如果发生 I/O 错误。

public final void writeShort(int v)throws IOException;

将一个 short 值以 2-byte 值形式写入基础输出流中，先写入高字节。如果没有抛出异常，则计数器 written 增加2。

参数：

v - 要写入的 short 值。

抛出：

        IOException - 如果发生 I/O 错误。

public final void writeChar(int v)throws IOException;

将一个 char 值以 2-byte 值形式写入基础输出流中，先写入高字节。如果没有抛出异常，则计数器 written 增加2。

参数：

v - 要写入的 char 值。

抛出：

        IOException - 如果发生 I/O 错误。

public final void writeInt(int v)throws IOException;

将一个 int 值以 4-byte 值形式写入基础输出流中，先写入高字节。如果没有抛出异常，则计数器 written 增加4。

参数：

v - 要写入的 int 值。

抛出：

        IOException - 如果发生 I/O 错误。

public final void writeLong(long v)throws IOException;

将一个 long 值以 8-byte 值形式写入基础输出流中，先写入高字节。如果没有抛出异常，则计数器 written 增加8。

参数：

v - 要写入的 long 值。

抛出：

        IOException - 如果发生 I/O 错误。

public final void writeFloat(float v)throws IOException;

使用 Float 类中的 floatToIntBits 方法将 float 参数转换为一个 int 值，然后将该 int 值以 4-byte 值形式写入基础输出流中，先写入高字节。如果没有抛出异常，则计数器 written 增加 4。

参数：

v - 要写入的 float 值。

抛出：

        IOException - 如果发生 I/O 错误。

public final void writeDouble(double v)throws IOException;

使用 Double 类中的 doubleToLongBits 方法将 double 参数转换为一个 long 值，然后将该 long 值以 8-byte 值形式写入基础输出流中，先写入高字节。如果没有抛出异常，则计数器 written 增加 8。

参数：

v - 要写入的 double 值。

抛出：

        IOException - 如果发生 I/O 错误。

public final void writeBytes(String s)throws IOException;

将字符串按字节顺序写出到基础输出流中。按顺序写出字符串中每个字符，丢弃其八个高位。如果没有抛出异常，则计数器 written 增加s 的长度。

参数：

s - 要写入的字节字符串。

抛出：

        IOException - 如果发生 I/O 错误。

public final void writeChars(String s)throws IOException;

将字符串按字符顺序写入基础输出流。通过 writeChar 方法将每个字符写入数据输出流。如果没有抛出异常，则计数器 written 增加 s 长度的两倍。

使用utd-16be编码形式。

参数：

s - 要写入的 String 值。

抛出：

        IOException - 如果发生 I/O 错误。

7、BufferedInputStream

是InputStream的子类，为IO提供了带缓冲区的操作，一般打开文件进行读取操作时，会加上缓冲，这种缓冲提高了InputStream的性能。比DataInputStream性能更好。

在创建 BufferedInputStream 时，会创建一个内部缓冲区数组。在读取或跳过流中的字节时，可根据需要从包含的输入流再次填充该内部缓冲区，一次填充多个字节。mark 操作记录输入流中的某个点，reset 操作使得在从包含的输入流中获取新字节之前，再次读取自最后一次mark 操作后读取的所有字节。

（1）构造函数

public BufferedInputStream(InputStream in);

构造参数为InputStream类型，是对InputStream的包装。

public BufferedInputStream(InputStream in,int size);

指定了缓冲区的大小。

8、BufferedOutputStream

是OutputStream的子类，为IO提供了带缓冲区的操作，一般打开文件进行写操作时，会加上缓冲，这种缓冲提高OutputStream的性能。比DataOutputStream性能更好。

在使用时，一定要使用flush方法来清空缓冲区，将缓冲区内容输入到指定文件中。

（1）构造函数

public BufferedOutputStream(OutputStream out);

public BufferedOutputStream(OutputStream,int size);

综上所述：

1、InputStream\OutputStream是IO流中的字节流操作的抽象父类，其余字节流操作都是继承自这一对类的。每次输出读入是以字节为单位进行的。一般文件的读写都可用字节流来完成。

2、FileInputStream\FileOutputStream是实现了对文件进行字节读写的一对具体类。

3、DataInputStream\DataOutputStream是继承自FilterInputStream\FilterOutputStream的一对具体类，加强了InputStream\OutputStream的功能，将具体操作进行封装，能直接对int、long、char等数据类型进行操作。构造函数的构造参数为InputStream\OutputStream。

4、BufferedInputStream\BufferedOutputStream是继承自InputStream\OutputStream的一对具体类，虽然没有像DataInputStream\DataOutputStream一样对操作进行封装，但性能比DataInputStream\DataOutputStream更好。构造函数的构造参数为InputStream\OutputStream。使用时要用flush方法将缓冲区中的数据直接发送到目标文件中。

二、字符流

对文件进行输入输出是以字符为单位的。一般是对文本的读写进行操作。但实现的底层还是对字节的操作。

字符流的实现涉及到了文件编码的问题，如GBK编码，一个汉字对应2个字节，一个英文对应1个字节；UTF-8编码，一个汉字对应3个字节，一个英文对应1个字节；UTF-16be编码，一个汉字对应2个字节，一个英文对应2个字节。

1、Reader

用于读取字符流的抽象类。具体实现靠继承它的子类。

2、Writer

用于写入字符流的抽象类。具体实现靠继承它的子类。

3、InputStreamReader

是Reader的子类，用于完成byte流解析为char流，是字节流通向字符流的桥梁。
（1）构造函数

public InputStreamReader(InputStream in);

是对InputStream的包装，读取InputStream输入的字节流，通过默认的编码格式转成字符流。

public InputStreamReader(InputStream in,String charsetName)throws UnsupportedEncodingException;

可以通过charsetName来指定需要的编码格式，来完成将InputStream读入的字节流，通过指定的编码格式转变为字符流。

（2）方法

public String getEncoding();

返回此流使用的字符编码的名称。

如果该编码有历史上用过的名称，则返回该名称；否则返回该编码的规范化名称。

如果使用 InputStreamReader(InputStream,String) 构造方法创建此实例，则返回的由此编码生成的唯一名称可能与传递给该构造方法的名称不一样。如果流已经关闭，则此方法将会返回 null。

返回：

此编码的历史名称，如果流已经关闭，则返回 null。

public int read()throws IOException;

读取单个字符。

返回：

读取的字符，如果已到达流的末尾，则返回 -1

抛出：

         IOException - 如果发生 I/O 错误

public int read(char[] chuf,int offset,int length)throws IOException;

将字符读入数组中的某一部分。

参数：

cbuf - 目标缓冲区

offset - 从其处开始存储字符的偏移量

length - 要读取的最大字符数

返回：

读取的字符数，如果已到达流的末尾，则返回 -1

抛出：

        IOException - 如果发生 I/O 错误

public boolean ready()throws IOException;

判断此流是否已经准备好用于读取。如果其输入缓冲区不为空，或者可从底层字节流读取字节，则InputStreamReader 已做好被读取准备。

返回：

如果保证下一个 read() 不阻塞输入，则返回 True，否则返回 false。注意，返回 false 并不保证阻塞下一次读取。

抛出：

         IOException - 如果发生 I/O 错误

public void close()throws IOException;

关闭该流并释放与之关联的所有资源。在关闭该流后，再调用 read()、ready()、mark()、reset()或 skip() 将抛出 IOException。关闭以前关闭的流无效。

抛出：

         IOException - 如果发生 I/O 错误

 

4、OutputStreamWriter

       是Writer的子类，用于完成char流解析为byte流，是字符流通向字节流的桥梁。

       每次使用都要记得调用.flush()方法来清空缓冲区。

（1）构造函数

public OutputStreamWriter(OutputStream out);

是对OutputStream的包装，能将字节流通过默认编码格式转变成为字节流输出。

public OutputStreamWriter(OutputStream out,String charsetName)throws UnsupportedWncodingException;

能通过指定的编码格式将字节流转变为字符流输出。

（2）方法

public String getEncoding();

返回此流使用的字符编码的名称。

如果该编码具有历史名称，则返回该名称；否则返回该编码的规范化名称。

如果此实例是用 OutputStreamWriter(OutputStream, String) 构造方法创建的，则返回的对于编码唯一的名称可能与传递给该构造方法的名称不同。如果流已经关闭，则此方法可能返回null。

返回：

此编码的历史名称；如果流已经关闭，则可能返回 null

public void write(int c)throws IOException;

写入单个字符。

参数：

c - 指定要写入字符的 int。

抛出：

         IOException - 如果发生 I/O 错误

public void write(char[] chuf,int off,int len)throws IOException;

写入字符数组的某一部分。

参数：

cbuf - 字符缓冲区

off - 开始写入字符处的偏移量

len - 要写入的字符数

抛出：

         IOException - 如果发生 I/O 错误

public void write(String str,int off,int len)throws IOException;

写入字符串的某一部分。

参数：

str - 字符串

off - 开始写入字符处的偏移量

len - 要写入的字符数

抛出：

         IOException - 如果发生 I/O 错误

public void flush()throws IOException;

刷新该缓冲区。

public void close()throws IOException;

5、FileReader

用来读取字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是适当的。但是无法修改编码格式，如果要自己指定编码格式及缓冲区大小，要回到 InputStreamReader。FileReader 用于读取字符流。要读取原始字节流，请考虑使用FileInputStream。  

（1）构造函数

public FileReader(String fileName)throws FileNotFoundException;

在给定从中读取数据的文件名的情况下创建一个新 FileReader。

参数：

fileName - 要从中读取数据的文件的名称

抛出：

        FileNotFoundException -如果指定文件不存在，或者它是一个目录，而不是一个常规文件，抑或因为其他某些原因而无法打开进行读取。

public FileReader(File file)throws FileNotFoundException;

在给定从中读取数据的 File 的情况下创建一个新 FileReader。

参数：

file - 要从中读取数据的 File

抛出：

        FileNotFoundException -如果文件不存在，或者它是一个目录，而不是一个常规文件，抑或因为其他某些原因而无法打开进行读取。

 

方法主要从InputStreamReader类、Reader类及Object类中继承而来。

6、FileWriter

用来写入字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是可接受的。但是无法修改编码格式，如果要自己指定编码格式及缓冲区大小，要回到OutputStreamWriter。FileWriter 用于写入字符流。要写入原始字节流，请考虑使用 FileOutputStream。  

文件是否可用或是否可以被创建取决于底层平台。特别是某些平台一次只允许一个 FileWriter（或其他文件写入对象）打开文件进行写入。在这种情况下，如果所涉及的文件已经打开，则此类中的构造方法将失败。

（1）构造函数

public FileWriter(String fileName)throws IOException;

根据给定的文件名构造一个 FileWriter 对象。

参数：

fileName - 一个字符串，表示与系统有关的文件名。

抛出：

        IOException - 如果指定文件存在，但它是一个目录，而不是一个常规文件；或者该文件不存在，但无法创建它；抑或因为其他某些原因而无法打开它

public FileWriter(String fileName,boolean append)throws IOException;

根据给定的文件名以及指示是否附加写入数据的 boolean 值来构造 FileWriter 对象。

参数：

fileName - 一个字符串，表示与系统有关的文件名。

append - 一个 boolean 值，如果为true，则将数据写入文件末尾处，而不是写入文件开始处。

抛出：

        IOException - 如果指定文件存在，但它是一个目录，而不是一个常规文件；或者该文件不存在，但无法创建它；抑或因为其他某些原因而无法打开它

public FileWriter(File file)throws IOException;

根据给定的 File 对象构造一个 FileWriter 对象。

参数：

file - 要写入数据的 File 对象。

抛出：

        IOException - 如果该文件存在，但它是一个目录，而不是一个常规文件；或者该文件不存在，但无法创建它；抑或因为其他某些原因而无法打开它

public FileWriter(File file,boolean append)throws IOException;

根据给定的 File 对象构造一个 FileWriter 对象。如果第二个参数为true，则将字节写入文件末尾处，而不是写入文件开始处。

参数：

file - 要写入数据的 File 对象

append - 如果为 true，则将字节写入文件末尾处，而不是写入文件开始处

抛出：

         IOException - 如果该文件存在，但它是一个目录，而不是一个常规文件；或者该文件不存在，但无法创建它；抑或因为其他某些原因而无法打开它

 

其余方法继承自OutputStreamWriter、Writer、Object。

7、BufferedReader

从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。 可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。 

通常，Reader 所作的每个读取请求都会导致对底层字符或字节流进行相应的读取请求。因此，建议用 BufferedReader 包装所有其 read() 操作可能开销很高的 Reader

（1）构造函数

public BufferedReader(Reader in);

创建一个使用默认大小输入缓冲区的缓冲字符输入流。对Reader进行封装。

public BufferedReader(Reader in,int sz);

创建一个使用指定大小输入缓冲区的缓冲字符输入流。 对Reader进行封装。

参数：

in - 一个 Reader

sz - 输入缓冲区的大小

抛出：

IllegalArgumentException- 如果 sz <= 0

 （2）方法

public String readLine()throws IOException;

读取一个文本行。通过下列字符之一即可认为某行已终止：换行 ('\n')、回车 ('\r') 或回车后直接跟着换行。

返回：

包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null

抛出：

IOException - 如果发生 I/O 错误

 

其余方法继承自Reader类并进行重写。

8、BufferedWriter

将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。

可以指定缓冲区的大小，或者接受默认的大小。在大多数情况下，默认值就足够大了。

该类提供了 newLine() 方法，它使用平台自己的行分隔符概念，此概念由系统属性line.separator 定义。

并非所有平台都使用新行符 ('\n') 来终止各行。因此调用此方法来终止每个输出行要优于直接写入新行符。

通常 Writer 将其输出立即发送到底层字符或字节流。除非要求提示输出，否则建议用 BufferedWriter 包装所有其 write() 操作可能开销很高的 Writer。

（1）构造函数

public BufferedWriter(Writer out);

创建一个使用默认大小输出缓冲区的缓冲字符输出流。对Writer进行封装。

public BufferedWriter(Writer out,int sz);

创建一个使用给定大小输出缓冲区的新缓冲字符输出流。 对Writer进行封装。

参数：

out - 一个 Writer

sz - 输出缓冲区的大小，是一个正整数

抛出：

IllegalArgumentException- 如果 sz <= 0

 （2）方法

public void newLine()throws IOException;

写入一个行分隔符。行分隔符字符串由系统属性 line.separator 定义，并且不一定是单个新行 ('\n') 符。 

其他方法继承自Writer并进行重写。

综上所述：

1、Reader\Writer是IO流中的字符流操作的抽象父类，其余字符流操作都是继承自这一对父类的。每次输出读入都是以字符为单位进行的。一般只对文本文件进行读写操作。需要考虑编码格式的问题。

2、InputStreamReader\OutputStreamWriter是继承自Reader\Writer的一对具体类。是对InputStream\OutputStream的封装。是字节流与字符流之间的桥梁，InputStreamReader能将字节流解析为字符流，OutputSreamWriter能将字符流解析为字节流。可以自行更改编码格式。

3、FileReader\FileWriter是继承自InputStreamReader\OutputStreamWriter的一对具体类。能完成对文件的字符流的读写操作。但是无法进行编码格式的设定，只能采用默认的编码格式，如要自行设定编码格式，只能返回采用InputStreamReader\OutputStreamWriter。

4、BufferedRead\BufferedWriter是继承自Reader\Writer的一对具体类。对Reader\Writer进行封装。设定了缓冲空间，来加强Reader\Writer的读写能力。且增加了对一行的读写能力。

使用while循环对读操作检测返回值是否为-1，若为-1则表示流已到文件的末尾。