字符流：通过一个转换流把字节流转换成字节流+编码表
        常见编码表：
                ACSII表：7位表示一个数据，最高位为符号位。
                Unicode表：国际标准码，融合了多种文字。
                ISO-8859-1：拉丁码表，8位表示一个数据。
                GB2312/GBK/GB18030：中文码表，GBK18030替代GBK
                BIG5：通行于台湾，香港地区的繁体字编码表。俗称“大五码”
                UTF-8：最多用三个字节来表示一个字符。能用一个就用一个，现在不行就用三个。

顶一下，，，，

1. package com.kxg.zifu;
   
2. 
   
3. import java.io.FileInputStream;
   
4. import java.io.FileOutputStream;
   
5. import java.io.IOException;
   
6. import java.io.InputStreamReader;
   
7. import java.io.OutputStreamWriter;
   
8. 
   
9. /*
   
10. * OutputStreamWriter:字符输出流
    
11. *                 public OutputStreamWriter(OutputStream out):根据默认编码表把字节流的数据转换为字符流
    
12. * public OutputStreamWriter(OutputStream out,Charset cs):根据指定编码表把字节流的数据转换为字符流
    
13. *
    
14. * InputStreamReader:字符输入流
    
15. *                 public InputStreamReader(InputStream in):根据默认编码表把字节流的数据转换为字符流
    
16. *                 public InputStreamReader(InputStream in,Charset cs):根据指定编码表把字节流的数据转换为字符流
    
17. *
    
18. */
    
19. public class ZiFu {
    
20.         public static void main(String[] args) throws IOException {
    
21.                 InputStreamReader isr = new InputStreamReader(new FileInputStream(
    
22.                                 "a.txt"));
    
23.                 OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
    
24.                                 "b.txt"));
    
25. 
    
26.                 int i = 0;
    
27.                 while ((i = isr.read()) != -1) {
    
28.                         osw.write(i);
    
29.                 }
    
30.                 osw.flush();
    
31. 
    
32.                 osw.close();
    
33.                 isr.close();
    
34.         }
    
35. }

复制代码

默认的编码表跟随系统，系统为简体中文，默认的编码表就为简体中文。


flush()和close()的区别：
flush():刷新缓冲区，刷新之后流对象还可以继续使用。
close():关闭流对象之前会刷新一次缓冲区，关闭之后流对象就不能继续使用。

FileWriter和FileReader：

1. package com.kxg.zifu;
   
2. 
   
3. import java.io.FileReader;
   
4. import java.io.FileWriter;
   
5. import java.io.IOException;
   
6. 
   
7. /*
   
8. * 由于转换流的名称过长，Java提供了其子类供我们使用。
   
9. * OutputStreamWriter = FileOutputStream + 编码表
   
10. * FileWriter = FileOutputStream + 编码表
    
11. */
    
12. public class ZiFuDemo {
    
13.         public static void main(String[] args) throws IOException {
    
14.                 // public FileReader(String fileName)
    
15.                 // 构造方法中可以直接给一个路径或者文件名
    
16.                 FileReader fr = new FileReader("a.txt");
    
17.                 FileWriter fw = new FileWriter("b.txt");
    
18.                
    
19.                 FileReader fr2 = new FileReader("a.txt");
    
20.                 FileWriter fw2 = new FileWriter("c.txt");
    
21. 
    
22.                 int i = 0;
    
23.                 while ((i = fr.read()) != -1) {
    
24.                         fw.write(i);
    
25.                 }
    
26. 
    
27.                 char[] chs = new char[1024];
    
28.                 int len = 0;
    
29.                 while ((len = fr2.read(chs)) != -1) {
    
30.                         fw2.write(chs);
    
31.                 }
    
32. 
    
33.                 fr.close();
    
34.                 fw.close();
    
35.                 fw2.close();
    
36.         }
    
37. }

复制代码

高效字符流：

1. package com.kxg.zifu;
   
2. 
   
3. import java.io.BufferedReader;
   
4. import java.io.BufferedWriter;
   
5. import java.io.FileReader;
   
6. import java.io.FileWriter;
   
7. import java.io.IOException;
   
8. 
   
9. public class ZiFuDemo2 {
   
10.         public static void main(String[] args) throws IOException {
    
11.                 BufferedReader br = new BufferedReader(new FileReader("a.txt"));
    
12.                 BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));
    
13. 
    
14.                 BufferedReader br2 = new BufferedReader(new FileReader("a.txt"));
    
15.                 BufferedWriter bw2 = new BufferedWriter(new FileWriter("c.txt"));
    
16. 
    
17.                 int i = 0;
    
18.                 while ((i = br.read()) != -1) {
    
19.                         bw.write(i);
    
20.                 }
    
21. 
    
22.                 char[] chs = new char[1024];
    
23.                 int len = 0;
    
24.                 while ((len = br2.read(chs)) != -1) {
    
25.                         bw2.write(chs);
    
26.                 }
    
27. 
    
28.                 br.close();
    
29.                 bw.close();
    
30.                 br2.close();
    
31.                 bw2.close();
    
32.         }
    
33. }

复制代码

高效字符流的特殊功能：一次读写一行

1. package com.kxg.zifu;
   
2. 
   
3. import java.io.BufferedReader;
   
4. import java.io.BufferedWriter;
   
5. import java.io.FileReader;
   
6. import java.io.FileWriter;
   
7. import java.io.IOException;
   
8. 
   
9. public class ZiFuDemo3 {
   
10.         public static void main(String[] args) throws IOException {
    
11.                 write();
    
12.                 read();
    
13.         }
    
14. 
    
15.         private static void write() throws IOException {
    
16.                 BufferedWriter bw = new BufferedWriter(new FileWriter("a.txt"));
    
17.                 for (int x = 0; x < 10; x++) {
    
18.                         bw.write("hello" + x);
    
19.                         bw.newLine();// 写入一个行分隔符，也就是换行
    
20.                         bw.flush();
    
21.                 }
    
22.                 bw.close();
    
23.         }
    
24. 
    
25.         private static void read() throws IOException {
    
26.                 BufferedReader br = new BufferedReader(new FileReader("a.txt"));
    
27.                 String line = null;
    
28.                 // readLine()方法读取到换行就结束了，打印的时候就要自己加换行。
    
29.                 while ((line = br.readLine()) != null) {
    
30.                         System.out.println(line);
    
31.                 }
    
32.                 br.close();
    
33.         }
    
34. }

复制代码