转载自并发编程网 – ifeve.com
Java IO类概述表
已经讨论了数据源、目标媒介、输入、输出和各类不同用途的Java IO类，接下来是一张通过输入、输出、基于字节或者字符、以及其他比如缓冲、解析之类的特定用途划分的大部分Java IO类的表格。
Java IO: 并发IO
原创文章，转载请注明： 转载自并发编程网 – ifeve.com本文链接地址: Java IO: 并发IO(http://ifeve.com/java-io-concurrent-io/)
原文链接 作者: Jakob Jenkov 译者: 李璟
有时候你可能需要并发地处理输入和输出。换句话说，你可能有超过一个线程处理输入和产生输出。比如，你有一个程序需要处理磁盘上的大量文件，这个任务可以通过并发操作提高性能。又比如，你有一个web服务器或者聊天服务器，接收许多连接和请求，这些任务都可以通过并发获得性能的提升。
如果你需要并发处理IO，这里有几个问题可能需要注意一下：
在同一时刻不能有多个线程同时从InputStream或者Reader中读取数据，也不能同时往OutputStream或者Writer里写数据。你没有办法保证每个线程读取多少数据，以及多个线程写数据时的顺序。
如果线程之间能够保证操作的顺序，它们可以使用同一个stream、reader、writer。比如，你有一个线程判断当前的输入流来自哪种类型的请求，然后将流数据传递给其他合适的线程做后续处理。当有序存取流、reader、writer时，这种做法是可行的。请注意，在线程之间传递流数据的代码应当是同步的。
注意：在Java NIO中，你可以让一个线程读写多个“channel”。比如，你有很多网络连接处于开启状态，但是每个连接中都只有少量数据，类似于聊天服务器，可以让一个线程监视多个频道(连接)。Java NIO是另一个话题了，会后续教程中介绍。
InputStream(转载http://ifeve.com/java-io-inputstream/)
InputStream类是Java IO API中所有输入流的基类。InputStream子类包括FileInputStream，BufferedInputStream，PushbackInputStream等等。参考Java IO概述这一小节底部的表格，可以浏览完整的InputStream子类的列表。
Java InputStream例子
InputStream用于读取基于字节的数据，一次读取一个字节，这是一个InputStream的例子：
InputStream inputstream = new FileInputStream("c:\data\input-text.txt");
int data = inputstream.read();
while(data != -1) {
//do something with data...
doSomethingWithData(data);
data = inputstream.read();
}
inputstream.close();
这个例子创建了FileInputStream实例。FileInputStream是InputStream的子类，所以可以把FileInputStream实例赋值给InputStream变量。
主要方法及讲解
1）、read()
read()方法返回从InputStream流内读取到的一个字节内容(译者注：0~255)，例子如下：
int data = inputstream.read();
你可以把返回的int类型转化成char类型：
char aChar = (char) data;
InputStream的子类可能会包含read()方法的替代方法。比如，DataInputStream允许你利用readBoolean()，readDouble()等方法读取Java基本类型变量int，long，float，double和boolean。
流末尾
如果read()方法返回-1，意味着程序已经读到了流的末尾，此时流内已经没有多余的数据可供读取了。-1是一个int类型，不是byte或者char类型，这是不一样的。
当达到流末尾时，你就可以关闭流了。
2）、read(byte[])
InputStream包含了2个从InputStream中读取数据并将数据存储到缓冲数组中的read()方法，他们分别是：
read()
read()方法返回从InputStream流内读取到的一个字节内容(译者注：0~255)，例子如下：
int data = inputstream.read();
你可以把返回的int类型转化成char类型：
char aChar = (char) data;
InputStream的子类可能会包含read()方法的替代方法。比如，DataInputStream允许你利用readBoolean()，readDouble()等方法读取Java基本类型变量int，long，float，double和boolean。
流末尾
如果read()方法返回-1，意味着程序已经读到了流的末尾，此时流内已经没有多余的数据可供读取了。-1是一个int类型，不是byte或者char类型，这是不一样的。
当达到流末尾时，你就可以关闭流了。
read(byte[])
InputStream包含了2个从InputStream中读取数据并将数据存储到缓冲数组中的read()方法，他们分别是：
OutputStream（转载http://ifeve.com/java-io-outputstream/）
OutputStream类是Java IO API中所有输出流的基类。子类包括BufferedOutputStream，FileOutputStream等等。参考Java IO概述这一小节底部的表格，可以浏览完整的子类的列表。
输出流和目标媒介
输出流往往和某些数据的目标媒介相关联，比如文件，网络连接，管道等。更多细节请参考Java IO概述。当写入到输出流的数据逐渐输出完毕时，目标媒介是所有数据的归属地。
Write(byte)
write(byte)方法用于把单个字节写入到输出流中。OutputStream的write(byte)方法将一个包含了待写入数据的int变量作为参数进行写入。只有int类型的第一个字节会被写入，其余位会被忽略。(译者注：写入低8位，忽略高24位)。
OutputStream的子类可能会包含write()方法的替代方法。比如，DataOutputStream允许你利用writeBoolean()，writeDouble()等方法将基本类型int，long，float，double，boolean等变量写入。
这是一个OutputStream的write()方法例子：
OutputStream output = new FileOutputStream("c:\data\output-text.txt");
while(hasMoreData()) {
int data = getMoreData();
output.write(data);
}
output.close();
这个例子首先创建了待写入的FileOutputStream。在进入while循环之后，循环的判断条件是hasMoreData()方法的返回值。hasMoreData()方法的实现不予展示，请把这个函数理解为：当有剩余可写数据时，返回true，否则返回false。
主要方法及讲解
1）、write(byte[])
OutputStream同样包含了将字节数据中全部或者部分数据写入到输出流中的方法，分别是write(byte[])和write(byte[], int offset, int length)。
write(byte[])把字节数组中所有数据写入到输出流中。
write(byte[], int offset, int length)把字节数据中从offset位置开始，length个字节的数据写入到输出流。
flush()
OutputStream的flush()方法将所有写入到OutputStream的数据冲刷到相应的目标媒介中。比如，如果输出流是FileOutputStream，那么写入到其中的数据可能并没有真正写入到磁盘中。即使所有数据都写入到了FileOutputStream，这些数据还是有可能保留在内存的缓冲区中。通过调用flush()方法，可以把缓冲区内的数据刷新到磁盘(或者网络，以及其他任何形式的目标媒介)中。
close()
当你结束数据写入时，需要关闭OutputStream。通过调用close()可以达到这一点。因为OutputStream的各种write()方法可能会抛出IO异常，所以你需要把调用close()的关闭操作方在finally块中执行。这是一个OutputStream调用close()的例子：
OutputStream output = null;
try{
output = new FileOutputStream("c:\data\output-text.txt");
while(hasMoreData()) {
int data = getMoreData();
output.write(data);
}
} finally {
if(output != null) {
output.close();
}
}
这个例子在finally块中调用close()方法。虽然这种方式可以确保OutputStream关闭，但却不是一个完美的异常处理方案。我在Java IO异常处理这文章中更加详细地探讨了IO的异常处理。
FileInputStream（转载http://ifeve.com/java-io-fileinputstream/）
FileInputStream可以以字节流的形式读取文件内容。FileInputStream是InputStream的子类，这意味着你可以把FileInputStream当做InputStream使用(FileInputStream与InputStream的行为类似)。
这是一个FileInputStream的例子：
InputStream input = new FileInputStream("c:\data\input-text.txt");
int data = input.read();while(data != -1) {
//do something with data...
doSomethingWithData(data);
data = input.read();
}
input.close();
请注意，为了清晰，这里忽略了必要的异常处理。想了解更多异常处理的信息，请参考Java IO异常处理。
FileInputStream的read()方法返回读取到的包含一个字节内容的int变量(译者注：0~255)。如果read()方法返回-1，意味着程序已经读到了流的末尾，此时流内已经没有多余的数据可供读取了，你可以关闭流。-1是一个int类型，不是byte类型，这是不一样的。
FileInputStream也有其他的构造函数，允许你通过不同的方式读取文件。请参考官方文档查阅更多信息。
其中一个FileInputStream构造函数取一个File对象替代String对象作为参数。这里是一个使用该构造函数的例子：
File file = new File("c:\data\input-text.txt");
InputStream input = new FileInputStream(file);
至于你该采用参数是String对象还是File对象的构造函数，取决于你当前是否已经拥有一个File对象，也取决于你是否要在打开FileOutputStream之前通过File对象执行某些检查(比如检查文件是否存在)。
FileOutputStream（转载http://ifeve.com/java-io-fileoutputstream/）
FileOutputStream可以往文件里写入字节流，它是OutputStream的子类，所以你可以像使用OutputStream那样使用FileOutputStream。
这是一个FileOutputStream的例子：
OutputStream output = new FileOutputStream("c:\data\output-text.txt");
while(moreData) {
int data = getMoreData();
output.write(data);
}
output.close();
请注意，为了清晰，这里忽略了必要的异常处理。想了解更多异常处理的信息，请参考Java IO异常处理。
FileOutputStream的write()方法取一个包含了待写入字节(译者注：低8位数据)的int变量作为参数进行写入。
FileOutputStream也有其他的构造函数，允许你通过不同的方式写入文件。请参考官方文档查阅更多信息。
文件内容的覆盖Override VS追加Appending
当你创建了一个指向已存在文件的FileOutputStream，你可以选择覆盖整个文件，或者在文件末尾追加内容。通过使用不同的构造函数可以实现不同的目的。
其中一个构造函数取文件名作为参数，会覆盖任何此文件名指向的文件。
OutputStream output = new FileOutputStream("c:\data\output-text.txt");
另外一个构造函数取2个参数：文件名和一个布尔值，布尔值表明你是否需要覆盖文件。这是构造函数的例子：
OutputStream output = new FileOutputStream("c:\data\output-text.txt", true); //appends to file
OutputStream output = new FileOutputStream("c:\data\output-text.txt", false); //overwrites file
写入字节数组
既然FileOutputStream是OutputStream的子类，所以你也可以往FileOutputStream中写入字节数组，而不需要每次都只写入一个字节。可以参考我的OutputStream教程查阅更多关于写入字节数组的信息。
flush()
当你往FileOutputStream里写数据的时候，这些数据有可能会缓存在内存中。在之后的某个时间，比如，每次都只有X份数据可写，或者FileOutputStream关闭的时候，才会真正地写入磁盘。当FileOutputStream没被关闭，而你又想确保写入到FileOutputStream中的数据写入到磁盘中，可以调用flush()方法，该方法可以保证所有写入到FileOutputStream的数据全部写入到磁盘中。
RandomAccessFile（转载http://ifeve.com/java-io-randomaccessfile/）
RandomAccessFile允许你来回读写文件，也可以替换文件中的某些部分。FileInputStream和FileOutputStream没有这样的功能。
创建一个RandomAccessFile
在使用RandomAccessFile之前，必须初始化它。这是例子：
RandomAccessFile file = new RandomAccessFile("c:\data\file.txt", "rw");
请注意构造函数的第二个参数：“rw”，表明你以读写方式打开文件。请查阅Java文档获知你需要以何种方式构造RandomAccessFile。
在RandomAccessFile中来回读写
在RandomAccessFile的某个位置读写之前，必须把文件指针指向该位置。通过seek()方法可以达到这一目标。可以通过调用getFilePointer()获得当前文件指针的位置。例子如下：
RandomAccessFile file = new RandomAccessFile("c:\data\file.txt", "rw");
file.seek(200);
long pointer = file.getFilePointer();
file.close();
读取RandomAccessFile
RandomAccessFile中的任何一个read()方法都可以读取RandomAccessFile的数据。例子如下：
RandomAccessFile file = new RandomAccessFile("c:\data\file.txt", "rw");
int aByte = file.read();
file.close();
read()方法返回当前RandomAccessFile实例的文件指针指向的位置中包含的字节内容。Java文档中遗漏了一点：read()方法在读取完一个字节之后，会自动把指针移动到下一个可读字节。这意味着使用者在调用完read()方法之后不需要手动移动文件指针。
写入RandomAccessFile
RandomAccessFile中的任何一个write()方法都可以往RandomAccessFile中写入数据。例子如下：
RandomAccessFile file = new RandomAccessFile("c:\data\file.txt", "rw");
file.write("Hello World".getBytes());
file.close();
与read()方法类似，write()方法在调用结束之后自动移动文件指针，所以你不需要频繁地把指针移动到下一个将要写入数据的位置。
RandomAccessFile异常处理
为了本篇内容清晰，暂时忽略RandomAccessFile异常处理的内容。RandomAccessFile与其他流一样，在使用完毕之后必须关闭
File
Java IO API中的FIle类可以让你访问底层文件系统，通过File类，你可以做到以下几点：
检测文件是否存在
读取文件长度
重命名或移动文件
删除文件
检测某个路径是文件还是目录
读取目录中的文件列表
请注意：File只能访问文件以及文件系统的元数据。如果你想读写文件内容，需要使用FileInputStream、FileOutputStream或者RandomAccessFile。如果你正在使用Java NIO，并且想使用完整的NIO解决方案，你会使用到java.nio.FileChannel(否则你也可以使用File)。
实例化一个java.io.File对象
在使用File之前，必须拥有一个File对象，这是实例化的代码例子：
File file = new File("c:\data\input-file.txt");
很简单，对吗？File类同样拥有多种不同实例化方式的构造函数。
检测文件是否存在
当你获得一个File对象之后，可以检测相应的文件是否存在。当文件不存在的时候，构造函数并不会执行失败。你已经准备好创建一个File了，对吧？
通过调用exists()方法，可以检测文件是否存在，代码如下：
File file = new File("c:\data\input-file.txt");
boolean fileExists = file.exists();
文件长度
通过调用length()可以获得文件的字节长度，代码如下：
File file = new File("c:\data\input-file.txt");
long length = file.length();
重命名或移动文件
通过调用File类中的renameTo()方法可以重命名(或者移动)文件，代码如下：
File file = new File("c:\data\input-file.txt");
boolean success = file.renameTo(new File("c:\data\new-file.txt"));
删除文件
通过调用delete()方法可以删除文件，代码如下：
File file = new File("c:\data\input-file.txt");
boolean success = file.delete();
delete()方法与rename()方法一样，返回布尔值表明是否成功删除文件，同样也会有相同的操作失败原因。
检测某个路径是文件还是目录
File对象既可以指向一个文件，也可以指向一个目录。可以通过调用isDirectory()方法，可以判断当前File对象指向的是文件还是目录。当方法返回值是true时，File指向的是目录，否则指向的是文件，代码如下：
File file = new File("c:\data");
boolean isDirectory = file.isDirectory();
读取目录中的文件列表
你可以通过调用list()或者listFiles()方法获取一个目录中的所有文件列表。list()方法返回当前File对象指向的目录中所有文件与子目录的字符串名称(译者注：不会返回子目录下的文件及其子目录名称)。listFiles()方法返回当前File对象指向的目录中所有文件与子目录相关联的File对象(译者注：与list()方法类似，不会返回子目录下的文件及其子目录)。代码如下：
File file = new File("c:\data");
String[] fileNames = file.list();
File[] files = file.listFiles();
ByteArray和Filter(转载http://ifeve.com/java-io-bytearray%E5%92%8Cfilter/)
本小节会简要概括Java IO中字节数组与过滤器的输入输出流，主要涉及以下4个类型的流：ByteArrayInputStream，ByteArrayOutputStream，FilterInputStream，FilterOutputStream。请注意，为了清晰，这里忽略了必要的异常处理。想了解更多异常处理的信息，请参考Java IO异常处理。
ByteArrayInputStream
原文链接
ByteArrayInputStream允许你从字节数组中读取字节流数据，代码如下：
byte[] bytes = ... //get byte array from somewhere.
InputStream input = new ByteArrayInputStream(bytes);
int data = input.read();
while(data != -1) {
//do something with data
data = input.read();
}
input.close();
如果数据存储在数组中，ByteArrayInputStream可以很方便地读取数据。如果你有一个InputStream变量，又想从数组中读取数据呢？很简单，只需要把字节数组传递给ByteArrayInputStream的构造函数，在把这个ByteArrayInputStream赋值给InputStream变量就可以了(译者注：InputStream是所有字节输入流流的基类，Reader是所有字符输入流的基类，OutputStream与Writer同理)。
ByteArrayOutputStream
ByteArrayOutputStream允许你以数组的形式获取写入到该输出流中的数据，代码如下：
ByteArrayOutputStream output = new ByteArrayOutputStream();
//write data to output stream
byte[] bytes = output.toByteArray();
FilterInputStream
Buffered和Data（转载http://ifeve.com/java-io-buffered%E5%92%8Cdata/）
BufferedInputStream
BufferedInputStream能为输入流提供缓冲区，能提高很多IO的速度。你可以一次读取一大块的数据，而不需要每次从网络或者磁盘中一次读取一个字节。特别是在访问大量磁盘数据时，缓冲通常会让IO快上许多。
为了给你的输入流加上缓冲，你需要把输入流包装到BufferedInputStream中，代码如下：
InputStream input = new BufferedInputStream(new FileInputStream("c:\data\input-file.txt"));
很简单，不是吗？你可以给BufferedInputStream的构造函数传递一个值，设置内部使用的缓冲区设置大小(译者注：默认缓冲区大小8 * 1024B)，就像这样：
InputStream input = new BufferedInputStream(new FileInputStream("c:\data\input-file.txt"), 8 * 1024);
这个例子设置了8KB的缓冲区。最好把缓冲区大小设置成1024字节的整数倍，这样能更高效地利用内置缓冲区的磁盘。
除了能够为输入流提供缓冲区以外，其余方面BufferedInputStream基本与InputStream类似。
BufferedOutputStream
与BufferedInputStream类似，BufferedOutputStream可以为输出流提供缓冲区。可以构造一个使用默认大小缓冲区的BufferedOutputStream(译者注：默认缓冲区大小8 * 1024B)，代码如下：
OutputStream output = new BufferedOutputStream(new FileOutputStream("c:\data\output-file.txt"));
也可以手动设置缓冲区大小，代码如下：
OutputStream output = new BufferedOutputStream(new FileOutputStream("c:\data\output-file.txt"), 8 * 1024);
为了更好地使用内置缓冲区的磁盘，同样建议把缓冲区大小设置成1024的整数倍。
除了能够为输出流提供缓冲区以外，其余方面BufferedOutputStream基本与OutputStream类似。唯一不同的时，你需要手动flush()方法确保写入到此输出流的数据真正写入到磁盘或者网络中。
DataInputStream
DataInputStream可以使你从输入流中读取Java基本类型数据，而不必每次读取字节数据。你可以把InputStream包装到DataInputStream中，然后就可以从此输入流中读取基本类型数据了，代码如下：
DataInputStream input = new DataInputStream(new FileInputStream("binary.data"));
int aByte = input.read();
int anInt = input.readInt();
float aFloat = input.readFloat();
double aDouble = input.readDouble();//etc.
input.close();
当你要读取的数据中包含了int，long，float，double这样的基本类型变量时，DataInputStream可以很方便地处理这些数据。
DataOutputStream
DataOutputStream可以往输出流中写入Java基本类型数据，例子如下：
DataOutputStream output = new DataOutputStream(new FileOutputStream("binary.data"));
output.write(45);
//byte data output.writeInt(4545);
//int data output.writeDouble(109.123);
//double data output.close();
其他方面与DataInputStream类似，不再赘述。
序列化与ObjectInputStream、ObjectOutputStream
Serializable
如果你希望类能够序列化和反序列化，必须实现Serializable接口，就像所展示的ObjectInputStream和ObjectOutputStream例子一样。
对象序列化本身就是一个主题。Java IO系列教程主要关注流、reader和writer，所以我不会深入探讨对象序列化的细节。并且，目前在网上已经有很多文章探讨了对象序列化，我将给出几个深入分析的资料链接，不再赘述。链接如下：
http://java.sun.com/developer/technicalArticles/Programming/serialization/
ObjectInputStream
ObjectInputStream能够让你从输入流中读取Java对象，而不需要每次读取一个字节。你可以把InputStream包装到ObjectInputStream中，然后就可以从中读取对象了。代码如下：
ObjectInputStream input = new ObjectInputStream(new FileInputStream("object.data"));
MyClass object = (MyClass) input.readObject(); //etc.
input.close();
在这个例子中，你读取的对象必须是MyClass的一个实例，并且必须事先通过ObjectOutputStream序列化到“object.data”文件中。(译者注：ObjectInputStream和ObjectOutputStream还有许多read和write方法，比如readInt、writeLong等等，详细信息请查看官方文档)
在你序列化和反序列化一个对象之前，该对象的类必须实现了java.io.Serializable接口。
ObjectOutputStream
ObjectOutputStream能够让你把对象写入到输出流中，而不需要每次写入一个字节。你可以把OutputStream包装到ObjectOutputStream中，然后就可以把对象写入到该输出流中了。代码如下：
ObjectOutputStream output = new ObjectOutputStream(new FileOutputStream("object.data"));
MyClass object = new MyClass(); output.writeObject(object); //etc.
output.close();
例子中序列化的对象object现在可以从ObjectInputStream中读取了。
同样，在你序列化和反序列化一个对象之前，该对象的类必须实现了java.io.Serializable接口。
Reader和Writer
Reader
Reader是Java IO中所有Reader的基类。Reader与InputStream类似，不同点在于，Reader基于字符而非基于字节。换句话说，Reader用于读取文本，而InputStream用于读取原始字节。
请记住，Java内部使用UTF8编码表示字符串。输入流中一个字节可能并不等同于一个UTF8字符。如果你从输入流中以字节为单位读取UTF8编码的文本，并且尝试将读取到的字节转换成字符，你可能会得不到预期的结果。
read()方法返回一个包含了读取到的字符内容的int类型变量(译者注：0~65535)。如果方法返回-1，表明Reader中已经没有剩余可读取字符，此时可以关闭Reader。-1是一个int类型，不是byte或者char类型，这是不一样的。
你通常会使用Reader的子类，而不会直接使用Reader。Reader的子类包括InputStreamReader，CharArrayReader，FileReader等等。可以查看Java IO概述浏览完整的Reader表格。
Reader通常与文件、字符数组、网络等数据源相关联，Java IO概述中同样说明了这一点。
Writer
Writer是Java IO中所有Writer的基类。与Reader和InputStream的关系类似，Writer基于字符而非基于字节，Writer用于写入文本，OutputStream用于写入字节。
同样，你最好使用Writer的子类，不需要直接使用Writer，因为子类的实现更加明确，更能表现你的意图。常用子类包括OutputStreamWriter，CharArrayWriter，FileWriter等。
Writer的write(int c)方法，会将传入参数的低16位写入到Writer中，忽略高16位的数据。
本章节将简要介绍InputStreamReader和OutputStreamWriter。细心的读者可能会发现，在之前的文章中，IO中的类要么以Stream结尾，要么以Reader或者Writer结尾，那这两个同时以字节流和字符流的类名后缀结尾的类是什么用途呢？简单来说，这两个类把字节流转换成字符流，中间做了数据的转换，类似适配器模式的思想。
InputStreamReader和OutputStreamWriter（转载http://ifeve.com/java-io-inputstreamreader%E5%92%8Coutputstreamwriter/）
InputStreamReader
InputStreamReader会包含一个InputStream，从而可以将该输入字节流转换成字符流，代码例子：
InputStream inputStream = new FileInputStream("c:\data\input.txt");
Reader reader = new InputStreamReader(inputStream);
int data = reader.read();
while(data != -1){
char theChar = (char) data;
data = reader.read();
}
reader.close();
注意：为了清晰，代码忽略了一些必要的异常处理。想了解更多异常处理的信息，请参考Java IO异常处理。
read()方法返回一个包含了读取到的字符内容的int类型变量(译者注：0~65535)。代码如下：
int data = reader.read();
你可以把返回的int值转换成char变量，就像这样：
char aChar = (char) data; //译者注：这里不会造成数据丢失，因为返回的int类型变量data只有低16位有数据，高16位没有数据
如果方法返回-1，表明Reader中已经没有剩余可读取字符，此时可以关闭Reader。-1是一个int类型，不是byte或者char类型，这是不一样的。
InputStreamReader同样拥有其他可选的构造函数，能够让你指定将底层字节流解释成何种编码的字符流。例子如下：
InputStream inputStream = new FileInputStream("c:\data\input.txt");
Reader reader = new InputStreamReader(inputStream, "UTF-8");
注意构造函数的第二个参数，此时该InputStreamReader会将输入的字节流转换成UTF8字符流。
OutputStreamWriter
OutputStreamWriter会包含一个OutputStream，从而可以将该输出字节流转换成字符流，代码如下：
OutputStream outputStream = new FileOutputStream("c:\data\output.txt");
Writer writer = new OutputStreamWriter(outputStream);
writer.write("Hello World");
writer.close();
OutputStreamWriter同样拥有将输出字节流转换成指定编码的字符流的构造函数。
FileReader和FileWriter（转载http://ifeve.com/java-io-filereader%E5%92%8Cfilewriter/）
本章节将简要介绍FileReader和FileWriter。与FileInputStream和FileOutputStream类似，FileReader与FileWriter用于处理文件内容。
FileReader
FileReader能够以字符流的形式读取文件内容。除了读取的单位不同之外(译者注：FileReader读取字符，FileInputStream读取字节)，FileReader与FileInputStream并无太大差异，也就是说，FileReader用于读取文本。根据不同的编码方案，一个字符可能会相当于一个或者多个字节。代码如下：
Reader reader = new FileReader("c:\data\input-text.txt");
int data = reader.read();
while(data != -1) {
//do something with data...
doSomethingWithData(data);
data = reader.read();
}
reader.close();
注意：为了清晰，代码忽略了一些必要的异常处理。想了解更多异常处理的信息，请参考Java IO异常处理。
read()方法返回一个包含了读取到的字符内容的int类型变量(译者注：0~65535)。如果方法返回-1，表明FileReader中已经没有剩余可读取字符，此时可以关闭FileReader。-1是一个int类型，不是byte或者char类型，这是不一样的。
FileReader拥有其他可选的构造函数，能够让你使用不同的方式读取文件，更多内容请查看官方文档。
FileReader会假设你想使用你所使用的JVM的版本的默认编码处理字节流，但是这通常不是你想要的，你可以手动设置编码方案。
如果你想明确指定一种编码方案，利用InputStreamReader配合FileInputStream来替代FileReader(译者注：FileReader没有可以指定编码的构造函数)。InputStreamReader可以让你设置编码处理从底层文件中读取的字节。
FileWriter
FileWriter能够把数据以字符流的形式写入文件。同样是处理文件，FileWriter处理字符，FileOutputStream处理字节。根据不同的编码方案，一个字符可能会相当于一个或者多个字节。代码如下：
Writer writer = new FileWriter("c:\data\output.txt");
while(moreData) {
String data = getMoreData();
write.write(data);
}
writer.close();
处理文件都会碰到的一个问题是，当前写入的数据是覆盖原文件内容还是追加到文件末尾。当你创建一个FileWriter之后，你可以通过使用不同构造函数实现你的不同目的。
以下的构造函数取文件名作为参数，将会新写入的内容将会覆盖该文件：
Writer writer = new FileWriter("c:\data\output.txt");
以下的构造函数取文件名和一个布尔变量作为参数，布尔值表明你是想追加还是覆盖该文件。例子如下：
Writer writer = new FileWriter("c:\data\output.txt", true); //appends to file
Writer writer = new FileWriter("c:\data\output.txt", false); //overwrites file
同样，FileWriter不能指定编码，可以通过OutputStreamWriter配合FileOutputStream替代FileWriter。
字符流的Buffered和Filter
本章节将简要介绍缓冲与过滤相关的reader和writer，主要涉及BufferedReader、BufferedWriter、FilterReader、FilterWriter。
BufferedReader
BufferedReader能为字符输入流提供缓冲区，可以提高许多IO处理的速度。你可以一次读取一大块的数据，而不需要每次从网络或者磁盘中一次读取一个字节。特别是在访问大量磁盘数据时，缓冲通常会让IO快上许多。
BufferedReader和BufferedInputStream的主要区别在于，BufferedReader操作字符，而BufferedInputStream操作原始字节。只需要把Reader包装到BufferedReader中，就可以为Reader添加缓冲区(译者注：默认缓冲区大小为8192字节，即8KB)。代码如下：
Reader input = new BufferedReader(new FileReader("c:\data\input-file.txt"));
你也可以通过传递构造函数的第二个参数，指定缓冲区大小，代码如下：
Reader input = new BufferedReader(new FileReader("c:\data\input-file.txt"), 8 * 1024);
这个例子设置了8KB的缓冲区。最好把缓冲区大小设置成1024字节的整数倍，这样能更高效地利用内置缓冲区的磁盘。
除了能够为输入流提供缓冲区以外，其余方面BufferedReader基本与Reader类似。BufferedReader还有一个额外readLine()方法，可以方便地一次性读取一整行字符。
BufferedWriter
与BufferedReader类似，BufferedWriter可以为输出流提供缓冲区。可以构造一个使用默认大小缓冲区的BufferedWriter(译者注：默认缓冲区大小8 * 1024B)，代码如下：
Writer writer = new BufferedWriter(new FileWriter("c:\data\output-file.txt"));
也可以手动设置缓冲区大小，代码如下：
Writer writer = new BufferedWriter(new FileWriter("c:\data\output-file.txt"), 8 * 1024);
为了更好地使用内置缓冲区的磁盘，同样建议把缓冲区大小设置成1024的整数倍。除了能够为输出流提供缓冲区以外，其余方面BufferedWriter基本与Writer类似。类似地，BufferedWriter也提供了writeLine()方法，能够把一行字符写入到底层的字符输出流中。值得注意是，你需要手动flush()方法确保写入到此输出流的数据真正写入到磁盘或者网络中。
FilterReader
与FilterInputStream类似，FilterReader是实现自定义过滤输入字符流的基类，基本上它仅仅只是简单覆盖了Reader中的所有方法。
就我自己而言，我没发现这个类明显的用途。除了构造函数取一个Reader变量作为参数之外，我没看到FilterReader任何对Reader新增或者修改的地方。如果你选择继承FilterReader实现自定义的类，同样也可以直接继承自Reader从而避免额外的类层级结构。
FilterWriter
内容同FilterReader，不再赘述。