InputStreamReader 和 OutputStreamWriter类用法-实例讲解很好

InputStreamReader 和 OutputStreamWriter类用法简介。

一、InputStreamReader类

InputStreamReader 将字节流转换为字符流。是字节流通向字符流的桥梁。如果不指定字符集编码，该解码过程将使用平台默认的字符编码，如：GBK。

构造方法：

InputStreamReader isr = new InputStreamReader(InputStream in);//构造一个默认编码集的InputStreamReader类

InputStreamReader isr = new InputStreamReader(InputStream in,String charsetName);//构造一个指定编码集的InputStreamReader类。

参数 in对象通过 InputStream in = System.in;获得。//读取键盘上的数据。

                                或者    InputStream in = new FileInputStream(String fileName);//读取文件中的数据。可以看出FileInputStream 为InputStream的子类。

主要方法：int read();//读取单个字符。

                  int read(char []cbuf);//将读取到的字符存到数组中。返回读取的字符数。

[java] view plain copy

1. public static void transReadNoBuf() throws IOException {  
2.         /** 
3.          * 没有缓冲区，只能使用read()方法。 
4.          */  
5.         //读取字节流  
6. //      InputStream in = System.in;//读取键盘的输入。  
7.         InputStream in = new FileInputStream("D:\\demo.txt");//读取文件的数据。  
8.         //将字节流向字符流的转换。要启用从字节到字符的有效转换，可以提前从底层流读取更多的字节.  
9.         InputStreamReader isr = new InputStreamReader(in);//读取  
10. //      InputStreamReader isr = new InputStreamReader(new FileInputStream("D:\\demo.txt"));
11. //综合到一句。  
12.               
13.         char []cha = new char[1024];  
14.         int len = isr.read(cha);  
15.         System.out.println(new String(cha,0,len));  
16.         isr.close();  
17.   
18.     }  
19.     public static void transReadByBuf() throws IOException {  
20.         /** 
21.          * 使用缓冲区 可以使用缓冲区对象的 read() 和  readLine()方法。 
22.          */  
23.         //读取字节流  
24. //      InputStream in = System.in;//读取键盘上的数据  
25.         InputStream in = new FileInputStream("D:\\demo.txt");//读取文件上的数据。  
26.         //将字节流向字符流的转换。  
27.         InputStreamReader isr = new InputStreamReader(in);//读取  
28.         //创建字符流缓冲区  
29.         BufferedReader bufr = new BufferedReader(isr);//缓冲  
30. //      BufferedReader bufr = new BufferedReader(new InputStreamReader
31. (new FileInputStream("D:\\demo.txt")));可以综合到一句。  
32.     /*  int ch =0; 
33.         ch = bufr.read(); 
34.         System.out.println((char)ch);*/  
35.         String line = null;  
36.         while((line = bufr.readLine())!=null){  
37.             System.out.println(line);  
38.         }  
39.         isr.close();  
40.     }  

 

二、OutputStreamWriter类

OutputStreamWriter 将字节流转换为字符流。是字节流通向字符流的桥梁。如果不指定字符集编码，该解码过程将使用平台默认的字符编码，如：GBK。

构造方法：

OutputStreamWriter osw = new OutputStreamWriter(OutputStream out);//构造一个默认编码集的OutputStreamWriter类

OutputStreamWriter osw = new OutputStreamWriter(OutputStream out,String charsetName);//构造一个指定编码集的OutputStreamWriter类。

参数 out对象通过 InputStream out = System.out;获得。//打印到控制台上。

                               或者    InputStream out = new FileoutputStream(String fileName);//输出到文件中。可以看出FileoutputStream 为outputStream的子类。

主要方法：void write(int c);//将单个字符写入。

                  viod write(String str,int off,int len);//将字符串某部分写入。

                  void flush();//将该流中的缓冲数据刷到目的地中去。

 

[java] view plain copy

1.     public static void transWriteNoBuf() throws IOException {  
2.         OutputStream out = System.out;//打印到控制台  
3. //      OutputStream out = new FileOutputStream("D:\\demo.txt");//打印到文件  
4.         OutputStreamWriter osr = new OutputStreamWriter(out);//输出  
5. //      OutputStreamWriter osr = new OutputStreamWriter(new FileOutputStream
6. ("D:\\demo.txt"));//两句可以综合到一句。  
7. //      int ch = 97;//a  
8. //      int ch = 20320;//你  
9. //      osr.write(ch);  
10.         String str = "你好吗？";//你好吗？  
11.         osr.write(str);  
12.         osr.flush();  
13.         osr.close();  
14.     }  
15.     public static void transWriteByBuf() throws IOException {  
16. //      OutputStream out = System.out;//打印到控制台。  
17.         OutputStream out = new FileOutputStream("D:\\demo.txt");//打印到文件。  
18.         OutputStreamWriter osr = new OutputStreamWriter(out);//输出  
19. //      OutputStreamWriter osr = new OutputStreamWriter(new FileOutputStream
20. ("D:\\demo.txt"));//综合到一句。  
21.         BufferedWriter bufw = new BufferedWriter(osr);//缓冲  
22. //      int ch = 97;//a  
23. //      int ch = 20320;//你  
24. //      osr.write(ch);  
25.         String str = "你好吗？\r\n我很好！";//你好吗？  
26.         bufw.write(str);  
27.         bufw.flush();  
28.         bufw.close();  
29.     }  

 流转换程序1：

[java] view plain copy

1. package IOtest;  
2.   
3. import java.io.BufferedReader;  
4. import java.io.BufferedWriter;  
5. import java.io.FileInputStream;  
6. import java.io.FileOutputStream;  
7. import java.io.IOException;  
8. import java.io.InputStream;  
9. import java.io.InputStreamReader;  
10. import java.io.OutputStream;  
11. import java.io.OutputStreamWriter;  
12.   
13. public class TransStreamtest {  
14.   
15.     /** 
16.      * 主要的类：    in1,    InputStream 
17.      *                      创建对象 InputStream in = System.in; 
18.      *              in2,    InputStreamReader  没有readLine()方法 
19.      *                      主要方法： 
20.      *                          read()读取单个字符，一个汉字也为一个字符。 
21.      *                          read(char[] cbuf)将字符读入数组。 
22.      *                          close().关闭此流和相关联资源。 
23.      *              in3,    BufferedReader     有read(),readLine()方法。 
24.      *              out1,   OutputStream 
25.      *                      创建对象 OutputStream in = System.out; 
26.      *              out2,   OutputStreamWriter   
27.      *                      主要方法： 
28.      *                          write(int c)//写入单个字符。 
29.      *                          write(char[] cbuf,int off,int len)//写入数组的某一部分 
30.      *                          write(String str,int off,int len)//写入字符串烦人某一部分。 
31.      *                          flush();//刷新该流中的缓冲。 
32.      *                          close(); 
33.      *              out3,   BufferedWriteer     有Write(int ch),newLine()方法。 
34.      *  
35.      *           
36.      * @throws IOException  
37.      */  
38.     public static void main(String[] args) throws IOException {  
39. //      transReadByBuf();  
40. //      transReadNoBuf();  
41.         transWriteNoBuf();  
42. //      transWriteByBuf();  
43.           
44.     }  
45.   
46.     public static void transWriteNoBuf() throws IOException {  
47.         OutputStream out = System.out;//打印到控制台  
48. //      OutputStream out = new FileOutputStream("D:\\demo.txt");//打印到文件  
49.         OutputStreamWriter osr = new OutputStreamWriter(out);//输出  
50. //      OutputStreamWriter osr = new OutputStreamWriter(new FileOutputStream
51. ("D:\\demo.txt"));//两句可以综合到一句。  
52. //      int ch = 97;//a  
53. //      int ch = 20320;//你  
54. //      osr.write(ch);  
55.         String str = "你好吗？";//你好吗？  
56.         osr.write(str);  
57.         osr.flush();  
58.         osr.close();  
59.     }  
60.         public static void transWriteByBuf() throws IOException {  
61. //          OutputStream out = System.out;//打印到控制台。  
62.             OutputStream out = new FileOutputStream("D:\\demo.txt");//打印到文件。  
63.             OutputStreamWriter osr = new OutputStreamWriter(out);//输出  
64. //          OutputStreamWriter osr = new OutputStreamWriter(new FileOutputStream
65. ("D:\\demo.txt"));//综合到一句。  
66.             BufferedWriter bufw = new BufferedWriter(osr);//缓冲  
67. //      int ch = 97;//a  
68. //      int ch = 20320;//你  
69. //      osr.write(ch);  
70.             String str = "你好吗？\r\n我很好！";//你好吗？  
71.             bufw.write(str);  
72.             bufw.flush();  
73.             bufw.close();  
74.     }  
75.   
76.       
77.     public static void transReadNoBuf() throws IOException {  
78.         /** 
79.          * 没有缓冲区，只能使用read()方法。 
80.          */  
81.         //读取字节流  
82. //      InputStream in = System.in;//读取键盘的输入。  
83.         InputStream in = new FileInputStream("D:\\demo.txt");//读取文件的数据。  
84.         //将字节流向字符流的转换。要启用从字节到字符的有效转换，可以提前从底层流读取更多的字节.  
85.         InputStreamReader isr = new InputStreamReader(in);//读取  
86. //      InputStreamReader isr = new InputStreamReader(new FileInputStream
87. ("D:\\demo.txt"));//综合到一句。  
88.               
89.         char []cha = new char[1024];  
90.         int len = isr.read(cha);  
91.         System.out.println(new String(cha,0,len));  
92.         isr.close();  
93.     }  
94.       
95.     public static void transReadByBuf() throws IOException {  
96.         /** 
97.          * 使用缓冲区 可以使用缓冲区对象的 read() 和  readLine()方法。 
98.          */  
99.         //读取字节流  
100. //      InputStream in = System.in;//读取键盘上的数据  
101.         InputStream in = new FileInputStream("D:\\demo.txt");//读取文件上的数据。  
102.         //将字节流向字符流的转换。  
103.         InputStreamReader isr = new InputStreamReader(in);//读取  
104.         //创建字符流缓冲区  
105.         BufferedReader bufr = new BufferedReader(isr);//缓冲  
106. //      BufferedReader bufr = new BufferedReader(new InputStreamReader
107. (new FileInputStream("D:\\demo.txt")));可以综合到一句。  
108.     /*  int ch =0; 
109.         ch = bufr.read(); 
110.         System.out.println((char)ch);*/  
111.         String line = null;  
112.         while((line = bufr.readLine())!=null){  
113.             System.out.println(line);  
114.         }  
115.         isr.close();  
116.     }  
117. }  

 流转换程序2：

[java] view plain copy

1. package readKey;  
2.   
3. import java.io.FileInputStream;  
4. import java.io.FileOutputStream;  
5. import java.io.FileReader;  
6. import java.io.FileWriter;  
7. import java.io.IOException;  
8. import java.io.InputStreamReader;  
9. import java.io.OutputStreamWriter;  
10.   
11. public class TransStreamDemo3 {  
12.   
13.     /** 
14.      * @param args 
15.      * @throws IOException  
16.      */  
17.     public static void main(String[] args) throws IOException {  
18. //      writeText_1();  
19. //      writeText_2();  
20. //      writeText_3();  
21. //      ReadTest_1();  
22. //      ReadTest_2();  
23. //      ReadTest_3();  
24.   
25.     }   
26.   
27.   
28.     public static void ReadTest_3() throws IOException {  
29.         InputStreamReader isr = new InputStreamReader(new FileInputStream
30. ("D:\\utf-8.txt"),"UTF-8");  
31.         char []ch = new char[20];  
32.         int len = isr.read(ch);  
33.         System.out.println(new String(ch,0,len) );  
34.         isr.close();      
35.           
36.     }  
37.     public static void ReadTest_2() throws IOException {  
38.         InputStreamReader isr = new InputStreamReader(new FileInputStream
39. ("D:\\utf-8.txt"),"GBK");  
40.         char []ch = new char[20];  
41.         int len = isr.read(ch);  
42.         System.out.println(new String(ch,0,len) );  
43.         isr.close();      
44.           
45.     }  
46.     public static void ReadTest_1() throws IOException {  
47.         FileReader fr = new FileReader("D:\\demo.txt");  
48.         char []ch = new char[20];  
49.         int len = fr.read(ch);  
50.         System.out.println(new String(ch,0,len) );  
51.         fr.close();       
52.     }  
53.   
54.   
55.     public static void writeText_3() throws IOException {  
56.         OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream
57. ("D:\\utf-8.txt"),"UTF-8");  
58.         osw.write("你好吗");  
59.         osw.close();      
60.     }  
61.   
62.     public static void writeText_2() throws IOException {  
63.         FileWriter fw = new FileWriter("D:\\gbk1.txt");  
64.         fw.write("你好啊");  
65.         fw.close();  
66.     }  
67.   
68.     public static void writeText_1() throws IOException {  
69.         OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream
70. ("D:\\gbk.txt"),"GBK");  
71.         /* 
72.          *和上面的等同  
73.          * FileWriter fw = new FileWriter("D:\\gbk1.txt"); 
74.          * 操作文件的字节流 + 默认的编码表 
75.          */  
76.         osw.write("你好吗");  
77.         osw.close();  
78.     }  
79. }  
80. 本文转自：http://blog.csdn.net/liuhenghui5201/article/details/8292552