Java IO之Reader与Writer对象常用操作（包含了编码问题的处理）
涉及到文件(非文件夹）内容的操作，如果是纯文本的情况下，除了要用到File(见之前文章），另外就必须用到字符输入流或字符输出流。
字符输入流：该流处理时，数据由外部流向程序（内存），一般指代“读取字符”，更清晰点地说：从外部读取字符数据到内存中。
字符输出流：该流处理时，数据由程序（内存）流向外部，一般指代“写入字符”，更清晰点地说：将字符数据从内存写入到外部。
在Java中，可使用：Reader 与 Writer 及其子类。
对字符的操作，采用 Reader与Writer。它们的为声明分别为：
public class FileReader extends InputStreamReader
public abstract class Writer implements Appendable, Closeable, Flushable
它们都是抽象类，需要由具体子类进行实例化。
Reader主要子类有：
- BufferedReader：缓存区字符输入流。从缓存区中读取字符数据。类似于BufferedInputStream。
- CharArrayReader：从字符数组中读取字符数据。类似于ByteArrayInputStream。
- FileReader：文件字符输入流。从文件中读取字符数据。类似于FileInputStream。
- FilterReader：过滤器字符输入流。用于装饰。其子类有：PushbackReader, BufferedReader。类似于FilterInputStream。
- InputStreamReader：字节字符转化流。从字节中读取字符数据。
- PipedReader：管道字符流。用于从管道中读取字符数据。类似于PipedInputStream。
- StringReader ：字符读取器。从字符中读取数据。
常用的有FileIReader，我们将以它为例。对比InputStream，Reader少了一些从字节中读取数据的类：AudioInputStream,ObjectInputStream，SequenceInputStream，但多了一些从字符中读取数据的类：InputStreamReader, StringReader。
Writer主要子类有：
- BufferedWriter：缓冲字符输出流。将字符数据写入缓冲区。类似于BufferedOutputStream。
- CharArrayWriter：字符数组输出流。将字符数据写入字符数组。类似于ByteArrayInputStream。
- FileWriter：文件输出流。将字符数据写入文件。类似于FileOutputStream。
- FilterWriter：过滤输出流。用于装饰。类似于FilterOutputStream。
- OutputStreamWriter：字节字符转化流。
- PipedWriter：管道字符流。用于将字符数据写入管道。类似于PipedOutputStream。
- PrintWriter：打印输出流。
- StringWriter ：字符输出流。
常用的有FileWriter，我们将以它为例。对比OutputStream，Writer少了一些将字节数据写入的类：ObjectOutputStream,但多了一些将字符数据写入的类：OutputStreamWriter,StrngWriter,PrintWriter
Reader与Writer的方法
Reader字符输入流，其主要方法有：
abstract void close() ：释放流对象。用于关闭资源。close()后无法进行read及skip等操作。所以一般在流操作结束后进行close()调用。
void mark(int readAheadLimit) ：标记流的位置。系统不一定支持。不推荐使用。
boolean markSupported() ：检测是否支持流位置标记。（mark方法与reset方法在其支持下才可用。一般能不用则不用此3个方法）
int read() ：从流中读取一个字符（一个或两个或三个字节，依据编码决定），如果没有数据，返回-1。
int read(char[] cbuf) ：从流中读取字符，并将数据存入到指定的字符数组中，读取的字符数为指定数组的长度。如果没有数据，返回-1。
abstract int read(char[] cbuf, int off, int len) ：从流中读取字符，并将数据存入到指定的字符数组中，读取的字符数为len，存入时从数组off开始存。如果没有数据，返回-1。
int read(CharBuffer target) ：从流中读取字符，并将数据存入到指定的字符缓冲上，读取的字符数为指定字符缓冲的大小。如果没有数据，返回-1。
boolean ready() ：判断流是否可以被读取。
void reset() ：从新设置流的开始。系统不一定支持。不推荐使用。
long skip(long n)：跳过指定数目字符。可以是正数负数或0（对于文件流来说，该方法虽然已被重载，但不可以用来解决系统不支持reset()问题。负数或0是不支持的，会抛出异常）。
输入字符流Reader用于“读取”，其中最常用的方法是：read(), read(char[] b), read(char[] b, int off, int len)
代码：（源代码文件编码为：ＧＢＫ）
1 import java.io.File;
2 import java.io.FileReader;
3 import java.io.IOException;
4 import java.io.Reader;
5
6 public class Reader001 {
7 public static void main(String[] args) throws IOException {
8 Reader r = new FileReader(new File("g:/java2019/file.txt"));//gbk编码的文件,内容为：123abc我爱你
9 int c = 0;
10 while((c=r.read())!=-1){
11 System.out.println(c+"(0x"+Integer.toHexString(c).toUpperCase()+"):"+(char)c);
12 }
13 r.close();
14 }
15 }
输出：
49(0x31):1
50(0x32):2
51(0x33):3
97(0x61):a
98(0x62):b
99(0x63):c
25105(0x6211):我
29233(0x7231):爱
20320(0x4F60):你
改变file.txt的编码为ＵＴＦ－８，再次运行，输出：
38168(0x9518):锘
65533(0xFFFD):?
49(0x31):1
50(0x32):2
51(0x33):3
97(0x61):a
98(0x62):b
99(0x63):c
37812(0x93B4):鎴
25120(0x6220):戠
22477(0x57CD):埍
28003(0x6D63):浣
65533(0xFFFD):?
产生乱码，可见，使用FileReader读取数据时，当源文件（程序）与被读取的文件编码不一致的时候，会产生乱码。
将源文件编码也修改为ＵＴＦ－８，执行输出：
65279(0xFEFF):
49(0x31):1
50(0x32):2
51(0x33):3
97(0x61):a
98(0x62):b
99(0x63):c
25105(0x6211):我
29233(0x7231):爱
20320(0x4F60):你
没有产生乱码，但是头部多了一些东西：65279(0xFEFF)。这个是utf-8的ＢＯＭ
为什么会多这个标记呢？这个与ＷＩＮＤＯＷＳ记事本保存时的编码设置有关。
要去除这个ＢＯＭ标记，可以用ＩＤＥ或高级文本编码器重新保存一下为ＵＴＦ－８（去ＢＯＭ）则可以
如果还是不行，则可以先用ＷＩＮＤＯＷＳ记事本保存为ＧＢＫ（保存为ＧＢＫ一般会去除ＢＯＭ），再次在ＩＤＥ或高级文本编码器中保存为ＵＴＦ－８。
对于字符流，往往涉及到编码问题。所以，在谈及字符操作之前，先来说明一下编码的问题。
WINDOW记事本保存文件时对编码的处理：
１。可以保存为ＡＮＳＩ（系统默认编码，简体中文中一般指ＧＢＫ，繁体中文中可能是ＢＩＧ５）或者ＵＴＦ－８等编码。
２。如果保存为ＡＮＳＩ内置编码，会去除文件中包含的ＢＯＭ标记。
３。如果保存为ＵＴＦ－８编码，会自动添加ＢＯＭ标记。
４。当保存为ＵＴＦ－８编码时，如果文件内容当中没有任何中文（ANSI）相关的内容出现，经常会自动保存为ANSI编码并去除BOM（不是一定，有些会有些不会。并且这个不仅仅是记事本会产生的问题，而是WINDOWS系统的问题，在WINDOWS下，其它文本编辑工具也会产生这样的问题）。很多时候明明保存为UTF-8保存，却变成了GBK就是这个原因，包括很多用代码生成和写入的纯文本文件。
UTF-8对于Java而言最大的问题是：Java编译器不支持带BOM的UTF-8，只支持无BOM的UTF-8源文件的编译。所以如果要采用UTF-8编写源文件的话，必须去除BOM。
去除BOM的方法：
- 1。用WINDOWS记事本先将编码设置为ANSI，再用支持UTF-8的高级文本编辑器（这种类型的编码器在从ANSI转码为UTF-8时不会主动加BOM，但从有BOM的UTF-8无法转ANSI无法去BOM。比如：Eclipse）保存为UTF-8无BOM编码。
- 2。直接用支持去BOM的高级文本编码器保存为UTF-8无BOM编码(比如：Editplus,Notepad++)。
WINDOWS中查看文件编码的方法：
用记事本打开该文件，然后点击”文件“，再点击”另存为“，这时有”编码“项，当前显示的编码就是该文件的编码。
不要太确信高级文本编辑器（或ＩＤＥ）显示的编码，因为有时候是错误的。
有时候是因为纯英文无ANSI文字造成了显示UTF-8而真实却是ANSI，有时候是因为UTF-8带BOM设置成ANSI（GBK）无效造成了显示ANSI真实却是UTF-8带BOM。在Eclipse，Notepad++都遇到过这种情形。
另外某些IDE进行编码指定时，并不会改变文件的编码，而是指定读取文件或者运行该文件生成的字节码时的附加编码。所以特别注意：IDE设置的编码真的不一定可靠！
所以要确认文件的编码还是要通过记事本的方法。不要太轻信高级编辑器或IDE。包括上边说到的“去除BOM的方法”还需要最终再用记事本打开的方法再确认一下。
随着上边的方案，我们可以做到无BOM的UTF-8。
为了避免BOM或编码问题，编辑器的选择原则是：通用一种编辑器进行文件编辑和编码，不采用另外的编辑器对文件进行修改或二次保存，并且不采用WINDOWS记事本进行编辑（它无法解决带BOM的UTF-8问题），只用WINDOWS记事本来确认编码。
java源文件的编码：是指.java文件的编码，在保存的时候可以选择ＡＮＳＩ（系统默认编码，简体中文中一般指ＧＢＫ，繁体中文中可能是ＢＩＧ５），ＵＴＦ－８等。一般都会在ａｎｓｉ和ｕｔｆ－８之间选择一个。由上边的问题可知：如果是UTF-8编码的源文件，必须是无BOM的UTF-8源文件，否则编译时会出现：错误: 需要class, interface或enum
java类文件的编码：是指.class文件的编码。由于.class文件由.java文件产生的，所以源文件什么编码会决定生成的类文件什么编码。但是类文件的编码，并不一定代表程序执行时的最终编码。
程序执行时的最终编码：由Java执行器当中的参数：java -Dfile.encoding=编码 决定。并且，一般情况下，如果没有指定（即省略-Dfile.encoding=编码), 则为类文件的编码。也就是说，默认情况（无指定）下，file.encoding的值由类文件编码决定。
在程序中输出 System.getProperty("file.encoding")或Charset.defaultCharset()可以获取file.encoding的指定值。这个值或是默认的（类文件编码），或是外部设置的（高级编辑器（或IDE）通过设置编码指定的，或是某些WEB运行环境下配置指定的）所以输出的值如果在命令行或IDE或WEB环境下，都可能会不相同。由于外部可以设置，所以说程序执行时的编码不一定是类文件的编码。另一方面证明了：虽然高级编辑器（或IDE）保存纯英文化的无BOM的UTF-8源文件不成功导致生成了GBK编码的类文件，但执行时仍然是UTF-8形式，就是因为设置UTF-8同时指定了file.encoding。所以在该高级编辑器（或IDE）下进行执行是没问题的，但要保证移植到其它编辑或运行环境下仍然想要正确的结果，那么就要对其它编辑或运行环境设置相同编码约定（有时不需要设定是因为已经一致）。
纯英文代码的GBK编码的类文件与UTF编码无ＢＯＭ的类文件对于执行器执行来说是兼容的，但file.encoding，它会对字符流之类以及对与编码相关的代码产生影响。所以说来说去最重要的还是file.encoding。这个是我们代码无法保证的，因环境变化而变化,我们要确保的是所有环境保持相同的编码，以避免开发与运行的环境不同导致错误的结果。但是另一个问题是，很多时候环境并不是我们能确保的（比如很多第三方环境无法进行配置），这时候涉及到与字符流或编码相关的代码时，我们应当使用支持编码设定的类并配合Charset类进行编码处理，这个是更推荐的办法。还是要强调：不要太依赖于源文件的编码。
有了以上编码基础现在开始分析运行FileReader程序读取file.txt的情况。
1。头部输出多余的FEFF ：这个属于UTF-8带BOM，先按照“去除BOM的方法”去除掉UTF-8中的BOM。再次输出的时候就不会有多余的BOM标记。
2。IDE与file.txt设置的编码不同的情况下，会出现乱码，设置的编码的情况下，不会出现乱码。
3。构造三个编码不同的文件：GBK编码文件（file-gbk.txt）,有BOM的UTF-8编码文件（file-bom.txt），无BOM的UTF-8编码文件（file-nobom.txt）进行测试。以验证上边结论。
(1) 假定IDE设置的源文件编码为：GBK。
分别读取上边3个文件进行输出验证（文件内容都为：123abc我爱你）
测试代码：
1 import java.io.File;
2 import java.io.FileReader;
3 import java.io.IOException;
4 import java.io.Reader;
5 import java.nio.charset.Charset;
6
7 public class Reader002 {
8 public static void main(String[] args) throws IOException {
9 System.out.println("Charset.defaultCharset():" + Charset.defaultCharset());
10 System.out.println("System.getProperty(\"file.encoding\"):" + System.getProperty("file.encoding"));
11
12 String[] paths = new String[] {
13 "g:/java2019/file-gbk.txt",
14 "g:/java2019/file-nobom.txt",
15 "g:/java2019/file-bom.txt" };
16
17 for (String path : paths) {
18 System.out.println("---------"+path+"----------");
19 Reader r = new FileReader(new File(path));
20 int c = 0;
21 while ((c = r.read()) != -1) {
22 System.out.println(c + "(0x" + Integer.toHexString(c).toUpperCase() + "):" + (char) c);
23 }
24 r.close();
25 }
26
27 }
28 }
输出：
Charset.defaultCharset():GBK
System.getProperty("file.encoding"):GBK
---------g:/java2019/file-gbk.txt----------
49(0x31):1
50(0x32):2
51(0x33):3
97(0x61):a
98(0x62):b
99(0x63):c
25105(0x6211):我
29233(0x7231):爱
20320(0x4F60):你
---------g:/java2019/file-nobom.txt----------
49(0x31):1
50(0x32):2
51(0x33):3
97(0x61):a
98(0x62):b
99(0x63):c
37812(0x93B4):鎴
25120(0x6220):戠
22477(0x57CD):埍
28003(0x6D63):浣
65533(0xFFFD):?
---------g:/java2019/file-bom.txt----------
38168(0x9518):锘
65533(0xFFFD):?
49(0x31):1
50(0x32):2
51(0x33):3
97(0x61):a
98(0x62):b
99(0x63):c
37812(0x93B4):鎴
25120(0x6220):戠
22477(0x57CD):埍
28003(0x6D63):浣
65533(0xFFFD):?
(2) 假定IDE设置的源文件编码为：UTF-8。
测试代码不变，仍然执行，输出：
Charset.defaultCharset():UTF-8
System.getProperty("file.encoding"):UTF-8
---------g:/java2019/file-gbk.txt----------
49(0x31):1
50(0x32):2
51(0x33):3
97(0x61):a
98(0x62):b
99(0x63):c
65533(0xFFFD):?
1200(0x4B0):?
65533(0xFFFD):?
65533(0xFFFD):?
65533(0xFFFD):?
---------g:/java2019/file-nobom.txt----------
49(0x31):1
50(0x32):2
51(0x33):3
97(0x61):a
98(0x62):b
99(0x63):c
25105(0x6211):我
29233(0x7231):爱
20320(0x4F60):你
---------g:/java2019/file-bom.txt----------
65279(0xFEFF):
49(0x31):1
50(0x32):2
51(0x33):3
97(0x61):a
98(0x62):b
99(0x63):c
25105(0x6211):我
29233(0x7231):爱
20320(0x4F60):你
另外，通过命令行也可以分别进行测试：
> java Reader002 回车输出：
Charset.defaultCharset():GBK
System.getProperty("file.encoding"):GBK
---------g:/java2019/file-gbk.txt----------
49(0x31):1
50(0x32):2
51(0x33):3
97(0x61):a
98(0x62):b
99(0x63):c
25105(0x6211):我
29233(0x7231):爱
20320(0x4F60):你
---------g:/java2019/file-nobom.txt----------
49(0x31):1
50(0x32):2
51(0x33):3
97(0x61):a
98(0x62):b
99(0x63):c
37812(0x93B4):鎴
25120(0x6220):戠
22477(0x57CD):埍
28003(0x6D63):浣
65533(0xFFFD):?
---------g:/java2019/file-bom.txt----------
38168(0x9518):锘
65533(0xFFFD):?
49(0x31):1
50(0x32):2
51(0x33):3
97(0x61):a
98(0x62):b
99(0x63):c
37812(0x93B4):鎴
25120(0x6220):戠
22477(0x57CD):埍
28003(0x6D63):浣
65533(0xFFFD):?
> java -Dfile.encoding=utf-8 Reader002 回车输出：
Charset.defaultCharset():UTF-8
System.getProperty("file.encoding"):utf-8
---------g:/java2019/file-gbk.txt----------
49(0x31):1
50(0x32):2
51(0x33):3
97(0x61):a
98(0x62):b
99(0x63):c
65533(0xFFFD):?
1200(0x4B0):?
65533(0xFFFD):?
65533(0xFFFD):?
65533(0xFFFD):?
---------g:/java2019/file-nobom.txt----------
49(0x31):1
50(0x32):2
51(0x33):3
97(0x61):a
98(0x62):b
99(0x63):c
25105(0x6211):我
29233(0x7231):爱
20320(0x4F60):你
---------g:/java2019/file-bom.txt----------
65279(0xFEFF):?
49(0x31):1
50(0x32):2
51(0x33):3
97(0x61):a
98(0x62):b
99(0x63):c
25105(0x6211):我
29233(0x7231):爱
20320(0x4F60):你
以上测试验证了上边的结论：
(1).执行程序的编码/Charset.defaultCharset()/System.getProperty("file.encoding") 是由运行环境的-Dfile-encoding=XXX决定的。没有指定时，-Dfile-encoding默认等于类文件的编码（这时才由类文件编码决定）
(2).执行程序的编码与要处理的文本文件的编码不一致时，在没有任何代码相关的编码处理时（上边的测试程序没有应用编码相关的代码处理，而FileReader默认使用Charset.defaultCharset()），会出现乱码。另外，程序中使用System.setProperty("file.encoding","utf-8");是没有作用的。
如果要处理的文件资源编码不可变（比如现在要读取file-nobom.txt这个UTF-8无BOM文件）同时file.encoding也无法设置(假定当前为GBK）。那么显示编码是冲突了，使用FileReader使用的是默认的无法改变的编码(与file.encoding相同：GBK)，如果要正常输出，这是不可能的，不过Reader的子类：InputStreamReader可以处理编码冲突的情况，它通过InputStream并指定编码，可以用来处理字符并解决编码问题。测试代码：
1 import java.io.File;
2 import java.io.FileInputStream;
3 import java.io.IOException;
4 import java.io.InputStreamReader;
5 import java.io.Reader;
6 import java.nio.charset.Charset;
7
8 public class Reader003 {
9 public static void main(String[] args) throws IOException {
10 System.out.println("Charset.defaultCharset():"+Charset.defaultCharset());
11 System.out.println("System.getProperty(\"file.encoding\"):"+System.getProperty("file.encoding"));
12 File file = new File("g:/java2019/file-nobom.txt");
13 Reader r = new InputStreamReader(new FileInputStream(file),"utf-8");//内容为：123abc我爱你
14 int c = 0;
15 while((c=r.read())!=-1){
16 System.out.println(c+"(0x"+Integer.toHexString(c).toUpperCase()+"):"+(char)c);
17 }
18 r.close();
19 }
20 }
输出：
Charset.defaultCharset():GBK
System.getProperty("file.encoding"):GBK
49(0x31):1
50(0x32):2
51(0x33):3
97(0x61):a
98(0x62):b
99(0x63):c
25105(0x6211):我
29233(0x7231):爱
20320(0x4F60):你
说明：通过InputStreamReader，可以在编码不匹配的情况下解决冲突问题，解决了FileReader默认编码的问题。在不能进行环境设置的情况下特别有用！！！
InputStreamReader的类声明如下：
public class InputStreamReader extends Reader
InputStreamReader主要的构造方法有：
public InputStreamReader(InputStream in)：采用默认编码利用InputStream进行构造。相同于：InputStreamReader(InputStream in, System.getProperty("file.encoding")) 或 InputStreamReader(InputStream in, Charset.defaultCharset())
public InputStreamReader(InputStream in, String charsetName)：通过字符串指明编码利用InputStream进行构造。常用。
public InputStreamReader(InputStream in, Charset cs)：通过Charset对象指明编码利用InputStream进行构造。
public InputStreamReader(InputStream in, CharsetDecoder dec)：较为复杂，少用。
现在继续说Reader的读取操作，可以更高效的处理的方法，是采用：read(char[] c, int off, int len) 来减少读取次数,毕竟每次读取会阻塞，减少了读取次数，效率就提高了。
一次性读取不同编码的文件内容，代码 ：
1 import java.io.File;
2 import java.io.FileInputStream;
3 import java.io.IOException;
4 import java.io.InputStreamReader;
5 import java.io.Reader;
6
7 public class Reader004 {
8 public static void main(String[] args) throws IOException {
9 File file = new File("g:/java2019/file-nobom.txt");
10 Reader r = new InputStreamReader(new FileInputStream(file),"utf-8");//内容为：123abc我爱你
11
12 char[] c = new char[(int)file.length()];
13 while((r.read(c))!=-1){
14 System.out.println(c);
15 }
16 r.close();
17 }
18 }
输出：123abc我爱你
非一次性读取代码：
1 import java.io.File;
2 import java.io.FileInputStream;
3 import java.io.IOException;
4 import java.io.InputStreamReader;
5 import java.io.Reader;
6 import java.util.Arrays;
7
8 public class Reader005 {
9 public static void main(String[] args) throws IOException {
10 File file = new File("g:/java2019/file-nobom.txt");
11 Reader r = new InputStreamReader(new FileInputStream(file),"utf-8");//内容为：123abc我爱你
12
13 int len=0;
14 char[] c = new char[3];
15 while((len=r.read(c))!=-1){
16 System.out.println(Arrays.copyOfRange(c, 0, len));
17 }
18 r.close();
19 }
20 }
输出：
123
abc
我爱你
Ｗriter字符输出流，其主要方法有：
Writer append(char c) ：以追加的方式写入一个字符。可链式调用。
Writer append(CharSequence csq) ：以追加的方式写入一个字符序列。可链式调用。
Writer append(CharSequence csq, int start, int end) ：以追加的方式写入一个指定开始与结束位置的字符序列。可链式调用。
abstract void close() ：释放流对象。用于关闭资源。close()后无法进行read及skip等操作。所以一般在流操作结束后进行close()调用。
abstract void flush() ：刷新输出流。特别在使用缓冲区时，如果在进行write和append方法当缓冲区超过输出数据量时，会自动刷新并写入，如果没有超过则不会进行刷新与写入。如果没有close()方法时末端未超过的可能不会进行写入。
不过如果采用JDK1.7的try-resource异常处理，会进行自动close()关闭，倒可以放心。
void write(char[] cbuf) ：写入一个字符数组数据。
abstract void write(char[] cbuf, int off, int len) ：写入一个指定开始与结束的字符数组数据。
void write(int c) ：写入一个字符数据。
void write(String str) ：写入一个字符串的数据。
void write(String str, int off, int len)：写入一个指定开始与结束的字符串的数据。
输出字符流Ｗriter用于“写入”，其中最常用的方法是：ｗrite(int c), write(char[] b), write(char[] b, int off, int len), writer(String str) , Write(String str, int off, int len)
测试代码：
1 import java.io.FileWriter;
2 import java.io.IOException;
3 import java.io.Writer;
4 import java.nio.charset.Charset;
5
6 public class Write001 {
7 public static void main(String[] args) throws IOException {
8 System.out.println(Charset.defaultCharset());
9 Writer w = new FileWriter("g:/java2019/file-001.txt");
10 w.write("我爱你");
11 w.close();
12 }
13 }
输出：UTF-8
生成或改变的文件格式为：ＵＴＦ－８
内容为：我爱你
说明：FileWriter按照默认的file.encoding生成了ｕｔｆ－８格式的文件，并且写入了相应的字符串“我爱你”
改下程序：将写入的字符串“我爱你”改成“123abc"
1 import java.io.FileWriter;
2 import java.io.IOException;
3 import java.io.Writer;
4 import java.nio.charset.Charset;
5
6 public class Write001 {
7 public static void main(String[] args) throws IOException {
8 System.out.println(Charset.defaultCharset());
9 Writer w = new FileWriter("g:/java2019/file-001.txt");
10 w.write("123abc");
11 w.close();
12 }
13 }
输出：UTF-8
文件格式变为：ＡＮＳＩ（ＧＢＫ）
文件内容：123abc
可见：纯英文下的ＵＴＦ－８在生成的时候，会自动变成ＧＢＫ。
现在可以进行纯文本文件的复制，代码为：
1 import java.io.FileReader;
2 import java.io.FileWriter;
3 import java.io.IOException;
4 import java.io.Reader;
5 import java.io.Writer;
6 import java.nio.charset.Charset;
7
8 public class Write002 {
9 public static void main(String[] args) {
10 System.out.println(Charset.defaultCharset());
11 try (Reader r = new FileReader("g:/java2019/file.txt");
12 Writer w = new FileWriter("g:/java2019/file-001.txt");) {
13 int len = 0;
14 char[] c = new char[1024];
15 while ((len = r.read(c)) != -1) {
16 w.write(c, 0, len);
17 }
18 } catch (IOException e) {
19 e.printStackTrace();
20 }
21 }
22 }
输出：utf-8
生成的ＵＴＦ－８格式文件file-001.txt内容为：123abc?????
显然乱码了，原因在于读取的资源文件编码为ＧＢＫ与file-encoding冲突。解决办法上边已经使用过多次。要么将file.txt编码更换为ｕｔｆ－８，要么采用读取转换流。这里用后者，代码更改为：
1 import java.io.FileInputStream;
2 import java.io.FileWriter;
3 import java.io.IOException;
4 import java.io.InputStreamReader;
5 import java.io.Writer;
6 import java.nio.charset.Charset;
7
8 public class Write003 {
9 public static void main(String[] args) {
10 System.out.println(Charset.defaultCharset());
11 try (InputStreamReader r = new InputStreamReader(new FileInputStream("g:/java2019/file.txt"),Charset.forName("GBK"));
12 Writer w = new FileWriter("g:/java2019/file-001.txt");) {
13 int len = 0;
14 char[] c = new char[1024];
15 while ((len = r.read(c)) != -1) {
16 w.write(c, 0, len);
17 }
18 } catch (IOException e) {
19 e.printStackTrace();
20 }
21 }
22 }
现在不会出现乱码了！！
另外，Java还为高效的操作字符流提供了缓冲字符输入流BufferedReader与缓冲字符输出流BufferedWriter，操作代码：
1 import java.io.BufferedReader;
2 import java.io.BufferedWriter;
3 import java.io.FileInputStream;
4 import java.io.FileWriter;
5 import java.io.IOException;
6 import java.io.InputStreamReader;
7 import java.nio.charset.Charset;
8
9 public class Write004 {
10 public static void main(String[] args) {
11 System.out.println(Charset.defaultCharset());
12 try (BufferedReader r = new BufferedReader(
13 new InputStreamReader(new FileInputStream("g:/java2019/file.txt"), Charset.forName("GBK")));
14 BufferedWriter w = new BufferedWriter(new FileWriter("g:/java2019/file-001.txt"));) {
15 int len = 0;
16 char[] c = new char[1024];
17 while ((len = r.read(c)) != -1) {
18 w.write(c, 0, len);
19 }
20 } catch (IOException e) {
21 e.printStackTrace();
22 }
23 }
24 }
可见，完全可以兼容我们自己写的复制代码，只需要替换特定的输入流与输出流的构造部分，其它部分可以不需要变化。另外，缓冲的字符流还提供了比较好用的一行一行的读取与写入的方法，以及写入换行的方法，见代码：
1 import java.io.BufferedReader;
2 import java.io.BufferedWriter;
3 import java.io.FileInputStream;
4 import java.io.FileWriter;
5 import java.io.IOException;
6 import java.io.InputStreamReader;
7 import java.nio.charset.Charset;
8
9 public class Write005 {
10 public static void main(String[] args) {
11 System.out.println(Charset.defaultCharset());
12 try (BufferedReader r = new BufferedReader(
13 new InputStreamReader(new FileInputStream("g:/java2019/file.txt"), Charset.forName("GBK")));
14 BufferedWriter w = new BufferedWriter(new FileWriter("g:/java2019/file-001.txt"));) {
15 String s = null;
16 while ((s = r.readLine())!=null) {
17 w.write(s);
18 w.newLine();
19 }
20 } catch (IOException e) {
21 e.printStackTrace();
22 }
23 }
24 }
另外还可以使用打印流PrintWriter进行文件复制：
1 import java.io.BufferedReader;
2 import java.io.FileInputStream;
3 import java.io.FileWriter;
4 import java.io.IOException;
5 import java.io.InputStreamReader;
6 import java.io.PrintWriter;
7 import java.nio.charset.Charset;
8
9 public class Write006 {
10 public static void main(String[] args) {
11 System.out.println(Charset.defaultCharset());
12 try (BufferedReader r = new BufferedReader(
13 new InputStreamReader(new FileInputStream("g:/java2019/file.txt"), Charset.forName("GBK")));
14 PrintWriter w = new PrintWriter(new FileWriter("g:/java2019/file-001.txt"));) {
15 String s = null;
16 while ((s = r.readLine())!=null) {
17 w.println(s);
18 }
19 } catch (IOException e) {
20 e.printStackTrace();
21 }
22 }
23 }
说明：打印流有println可以输出并换行（内部调用了newLine()）。另外，打印流的write(int c)与print(int c)区别：前者会转化为字符进行写入，后者直接原样写入。
其它的字符处理类：暂不介绍。
总结：
- FileReader与FileWriter可以以字符流形式处理文件，进行读取或写入操作。
- 要进行高效的字符流处理，可以使用内置的BufferedReader及BufferedWriter缓冲字符流，它可以处理各种Reader及Writer(不仅仅是FileReader及FileWriter）
- 使用read(char[] b, int off, int len)及write(char[], int off, int len) 可以更高效的进行字符复制（可以替代缓冲字符流）
- 对于文件编码不一致时，可以采用转换输入流InputStreamReader或转换输出流OutputStreamWriter进行转码操作
原文地址：https://www.cnblogs.com/dreamyoung/p/11131987.html