【转载】J2SE知识点归纳笔记(七)---Java IO Part 4：基本字符流

接着上节字节流继续讲下，IO流这块的内容挺重要，文件存储

注：本文转载自coder-pig

原文连接：http://blog.csdn.net/coder_pig/article/details/45333613

本节引言:

上一节中,我们对于Java IO流中的一些基本字节流进行了学习,他们都是InputStream与

OutputStream的子类;本节学习的字符流则是Reader与Writer的子类,好了,话不多说,

开始本节内容!

本节正文:

1.Reader类与Writer类的相关方法:

PS:~小猪比较懒,所以就不一个个敲方法与解析了,直接截API的图吧,大家可自行翻阅API文档:

①Reader类的相关方法:

②Writer类的相关方法:

一些要搞清楚的东西:

1)二进制文件与文本文件的区别:

答:如果一个文件专用于存储文本字符，而又没有包含文本之外的字符，

     就可称之为文本文件。除此之外的文件就是二进制文件!

2)InputStream,OutputStream和Reader,Writer的区别:

答:前者是处理字节流,后者是处理字符流;

    前者主要用于操作二进制数据的内容,后者则用于操作文本数据的内容;

    前者直接操作byte数组,后者在操作时还会进行Decode和Encode~

2.FileReader与FileWriter类的使用: 

构造方法:

代码示例:

这里演示的代码是:读取文件里的内容,以及完成简单的文件复制

接下来就来写代码了,大家自己写的时候记得进行异常捕获哦~

①往文件写入数据，读取数据显示:

1. FileWriter fileWriter = new FileWriter("D:/one.txt");  
2. fileWriter.write("我是萌萌的Coder-pig~");  
3. fileWriter.close();  
4. //读取文件中的内容:  
5. FileReader fileReader = new  FileReader("D:/one.txt");  
6. //用户缓冲的字符数组  
7. char[] cbuf = new char[1024];  
8. int len = fileReader.read(cbuf);  
9. System.out.println(new String(cbuf,0,len));    
10. fileReader.close();    
11. fileWriter.close();  

运行截图:

②文件复制的实现:

这里有两种,随你选

方法1：

1. FileReader fileReader = new  FileReader("D:/one.txt");  
2.         FileWriter fileWriter = new FileWriter("E:/one.txt");  
3.         //复制文件的最简单写法  
4.         char [] cbuf=new char[1024]; //字符数组    
5.         int len=fileReader.read(cbuf);    
6.         fileWriter.write(cbuf);  
7.         fileReader.close();  
8.         fileWriter.close();  

方法2:

1. FileReader fileReader = new  FileReader("D:/one.txt");  
2. FileWriter fileWriter = new FileWriter("E:/one.txt");  
3. char []buf = new char[1024];    
4.       int len = 0;    
5.       //读一个数组大小，写一个数组大小方法。    
6.       while((len = fileReader.read(buf)) != -1){    
7.         fileWriter.write(buf, 0, len);                  
8.       }    
9. fileReader.close();  
10. fileWriter.close();  

③要注意的地方:

使用FileWriter的时候要注意:

FileReader与FileWriter读写文件采取的是平台默认编码（视操作系统而定）,比如中文的win为gbk,

英文的win为iso,当要写入的文本文件编码和平台默认编码不一致时，就会出现中文乱码的情况。

这时可用OutputStreamWriter来读取。这个下面会讲,莫急~

3.CharArrayReader与CharArrayWriter类:

前面我们学过了CharArrayInputStream与CharArrayOutputStream类,其实是类似的,只不过这个

是字符,前面两个是字节的而已,同样他有个toCharArray( )的方法!其实也没什么好讲的,用的并不多,

而且还要借助其他流..

这里给大家写个简单的写数据到文件的例子吧:

1. CharArrayWriter f = new CharArrayWriter();  
2.           String str = "才几点，睡你麻痹，起来嗨~";  
3.           char []buf1 = new char[str.length()];  
4.           str.getChars(0, str.length(), buf1, 0);  
5.           //写入缓冲区  
6.           f.write(buf1);  
7.           char c[] = f.toCharArray();  
8.           FileWriter f2 = new FileWriter("D:/test.txt");  
9.           f.writeTo(f2);  
10.           f2.close();  
11.          }  

运行后就能看到D盘生成一个test.txt文件了,感觉还不如直接用FileWriter

4.PipedReader与PipedWriter

这个和前面学的PipedInputStream与PipedWriter也是类似的,唯一的不同只是

byte[]变成了char[]而已!代码相比之前只是改了一点点而已~

1. import java.io.IOException;  
2. import java.io.PipedOutputStream;  
3. import java.io.PipedWriter;  
4.   
5. public class SendThread extends Thread{  
6.     private PipedWriter out = new PipedWriter();     
7.     public PipedWriter getOutputStream(){     
8.         return out;     
9.     }     
10.     public void run(){     
11.             String message = "我是PipedWriter写入的东西" ;     
12.             try {     
13.                 out.write(message.toCharArray());     
14.                 out.close();     
15.             } catch (IOException e) {     
16.                 e.printStackTrace();     
17.             }     
18.         }     
19. }  

1. import java.io.IOException;  
2. import java.io.PipedInputStream;  
3. import java.io.PipedReader;  
4.   
5. public class ReceiverThread extends Thread {  
6.     private PipedReader in = new PipedReader();  
7.   
8.     public PipedReader getInputStream() {  
9.         return in;  
10.     }  
11.   
12.     public void run() {  
13.         char[] buf = new char[1024];  
14.         try {  
15.             int len = in.read(buf);  
16.             //打印另外一个线程输入的流  
17.             System.out.println(new String(buf, 0, len));  
18.             in.close();  
19.         } catch (IOException e) {  
20.             e.printStackTrace();  
21.         }  
22.     }  
23. }  

1. import java.io.IOException;  
2. import java.io.PipedInputStream;  
3. import java.io.PipedOutputStream;  
4. import java.io.PipedReader;  
5. import java.io.PipedWriter;  
6.   
7. public class Test5 {  
8.     public static void main(String[] args) {  
9.         ReceiverThread rThread = new ReceiverThread();  
10.         SendThread sThread = new SendThread();  
11.         // 获取对应流:  
12.         PipedWriter out = sThread.getOutputStream();  
13.         PipedReader in = rThread.getInputStream();  
14.         try {  
15.             // 管道链接  
16.             out.connect(in);  
17.             sThread.start();  
18.             rThread.start();  
19.         } catch (IOException e) {  
20.             e.printStackTrace();  
21.         }  
22.     }  
23. }  

运行截图:

5.InputStreamReader与InputStreamWriter

这两个流是字节流与字符流进行转换的流,但是有一点要注意,这两个玩意竟然是:

FileReader与FileWriter的父类;

前者是Reader的子类,输入字节流向字符流的桥梁;

后者是Writer的子类,输出字符流向字节流的桥梁！

所以不管我们的操作如何,最后都是以字节的形式保存在文件中!!!

至于设置编码,可以直接在构造方法中定义:

比如:

new InputStreamReader(new FileInputStream("d:\\books.txt"),"UTF-8");

好吧,写个简单例子:

1. public static void main(String[] args) throws Exception {  
2.         String filename1 = "D:/file.txt";  
3.         String filename2 = "D:/副本-file.txt";  
4.         InputStreamReader isr = new InputStreamReader(new FileInputStream(filename1),"GBK");  
5.         OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(filename2),"GBK");  
6.         int ch = 0;  
7.         while((ch = isr.read()) != -1)  
8.         {  
9.             System.out.print((char)ch);  
10.             osw.write(ch);  
11.         }  
12.         System.out.println("\n文件复制完毕");  
13.         isr.close();  
14.         osw.close();  
15.     }  

最后说两句:

好的,关于Java IO中的字节流就说到这里,下一节我们要学习的是缓冲流,

最后回顾下本节内容:

①Reader类与Writer类的相关方法:

②2.FileReader与FileWriter类的使用:文件读写,但是他们是⑤的子类哦!

③CharArrayReader与CharArrayWriter类:字符数组类,用于缓冲的是字符数组;

④PipedReader与PipedWriter类:管道字符类,传递的是字符咯~

⑤InputStreamReader与InputStreamWriter:字符与字节的转换流,是②的父类,所有文件都是以字节

                 流的形式存储的哦,不管你是用FileInputStream,或者②⑤,结果都一样~

ps:其实本节和Part 3的内容差不多,只是字节改成字符而已~