基础_IO流学习笔记_文本文件读取及复制、字符流的缓冲区和装饰设计模式

1、使用read()读取文本文件

FileReader用来读取字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是适当的。要自己指定这些值，可以先在 FileInputStream 上构造一个 InputStreamReader。

调用读取流对象的read()方法，读取单个字符，得到的结果是字符的ascii码，下面是使用read()读取文本文件的简单例子，以及一些要点说明：

[java]  view plain copy

1. public static void readTxtByRead(){  
2.           
3.         Reader reader = null;  
4.         String spr = File.separator;  
5.         int result;  
6.           
7.         //创建一个文件读取流对象，和指定名称的文件相关联。  
8.         //要保证该文件是已经存在的，如果不存在，会抛出FileNotFoundException异常  
9.         try {  
10.             reader = new FileReader("G:" + spr + "TestFolder" + spr + "writer.txt");  
11.             //调用读取流对象的read()方法，读取单个字符，得到的结果是字符的ascii码  
12.             //read()：一次读一个字符，并且会自动往下读，达到流的末尾，则返回-1  
13.               
14.             while((result = reader.read()) != -1){  
15.                 P.rintln(result + " " + (char)result);      //强制转换为char类型  
16.             }  
17.               
18. //          while(true){  
19. //              result = reader.read();  
20. //              if(result == -1){  
21. //                  break;  
22. //              }  
23. //              P.rintln(result + " " + (char)result);      //强制转换为char类型  
24. //          }  
25.               
26.         } catch (FileNotFoundException e) {  
27.             e.printStackTrace();  
28.         } catch (IOException e) {  
29.             e.printStackTrace();  
30.         } finally {  
31.             try {  
32.                 if(reader != null){  
33.                     reader.close();  
34.                 }  
35.             } catch (IOException e) {  
36.                 e.printStackTrace();  
37.             }  
38.         }  
39.     }  

2、使用read(char[] cbuf)读取文本文件

下面是使用read(char[] cbuf)读取文本文件的简单例子，以及一些要点说明：

[java]  view plain copy

1. public static void readTxtByReads() throws IOException{ //使用read(char[] cbuf)读取文本文件  
2.           
3.         Reader reader = null;  
4.         char[] results = new char[1024];        //定义字符数组，用于存储读到的字符，一般定义长度为1024  
5.         String spr = File.separator;  
6.         int num = 0;  
7.           
8.         reader = new FileReader("G:" + spr + "TestFolder" + spr + "writer.txt");  
9.         while((num = reader.read(results)) != -1){      //read(char[])返回的是读到的字符个数  
10.             P.rintln(new String(results, 0, num));      //以num截取有效位输出  
11.         }  
12.         reader.close();  
13.     }  

3、文本文件读取练习

下面是本机测试的答案代码：

[java]  view plain copy

1. public static void readJava() throws IOException{   //读取练习  
2.           
3.         Reader reader = null;  
4.         char[] results = new char[1024];  
5.         String spr = File.separator;        //通用的文件分隔符  
6.         int num = 0;  
7.           
8.         reader = new FileReader("G:" + spr + "Workspaces" + spr + "MyEclipse 9" + spr + "Study" +   
9.                 spr + "src" + spr + "com" + spr + "xgh" + spr + "itheima" + spr + "learn" + spr + "SystemAndOthers.java");  
10.         while((num = reader.read(results)) != -1){  
11.             P.rint(new String(results, 0, num));  
12.         }  
13.         reader.close();  
14.     }  

4、copy文件

copy文件的原理：其实就是将源盘下的文件数据存储到目标盘的一个文件中。

例，将C盘一个文本文件复制到D盘。其步骤如下：

1：在D盘创建一个文件，用于存储C盘文件中的数据

2：定义读取流和C盘文件关联

3：通过不断的读写完成数据存储

4：关闭资源

以下为文件copy练习，以及一些要点说明：

[java]  view plain copy

1. public static void copyFile() throws IOException{ //从C盘读一个字符，就往D盘写一个字符  
2.           
3.         //创建目标文件  
4.         Writer writer = new FileWriter("D:" + File.separator + "export_copy.xml");  
5.         //与源文件关联  
6.         Reader reader = new FileReader("C:" + File.separator + "export.xml");  
7.         int result = 0;  
8.           
9.         while((result = reader.read()) != -1){  
10.             writer.append((char)result);    //将获取的字符append到writer中，最终将writer写入到文件中  
11. //          writer.write((char)result);     //获取一个字符就写入一个字符，IO次数多  
12.         }  
13.           
14.         reader.close();  
15.         writer.close();  
16.     }  
17.       
18.     public static void copyFiles(){     //使用read(char[] cs)读取源文件写入目标文件  
19.           
20.         Writer writer = null;  
21.         Reader reader = null;  
22.         char[] results = new char[1024];  
23.         int num = 0;  
24.           
25.         try {  
26.             writer = new FileWriter("D:" + File.separator + "export_copy.xml");  
27.             reader = new FileReader("C:" + File.separator + "export.xml");  
28.               
29.             while((num = reader.read(results)) != -1){  
30.                 writer.write(results, 0, num);          //批量写入，可以减少磁盘IO次数  
31.             }  
32.               
33.         } catch (IOException e) {  
34.             throw new RuntimeException("读写失败");  
35.         } finally{  
36.             if(writer != null){  
37.                 try {  
38.                     writer.close();  
39.                 } catch (IOException e) {  
40.                     e.printStackTrace();  
41.                 }  
42.             }  
43.             if(reader != null){  
44.                 try {  
45.                     reader.close();  
46.                 } catch (IOException e) {  
47.                     e.printStackTrace();  
48.                 }  
49.             }  
50.         }  
51.           
52.     }  

5、BufferedWriter
 缓冲区的出现提高了对数据的读写效率；流的缓冲区对应类：BufferedWriter、BufferedReader；缓冲区要结合流才可以使用；在流的基础上对流的功能进行了增强。

BufferedWriter将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。 可以指定缓冲区的大小，或者接受默认的大小。
缓冲区的出现是为了提高流的操作效率而出现的，所以在创建缓冲区之前，必须要先有流对象。缓冲技术的原理其实是这个对象封装了数组。

下面是一个BufferedWriter的简单练习，以及一些要点说明：

[java]  view plain copy

1. public static void bufferedWriter() throws Exception{  
2.           
3.         Writer fileWriter = null;  
4.         BufferedWriter bufferedWriter = null;  
5.         String spr = File.separator;  
6.           
7.         //实例化字符写入流对象  
8.         fileWriter = new FileWriter("G:" + spr + "TestFolder" + spr + "writer.txt");  
9.           
10.         //为了提高字符写入流的效率，加入了缓冲区技术。  
11.         //只要将需要被提高效率的流对象作为参数传递给缓冲区的构造函数即可  
12.         bufferedWriter = new BufferedWriter(fileWriter);  
13.         for(int i = 0; i < 5; i++){  
14.             bufferedWriter.write("我是被缓冲流写入的");  
15.             bufferedWriter.newLine();   //插入换行符，可以跨平台使用  
16.             bufferedWriter.flush();     //只要用到缓冲区，就要记得刷新  
17.         }  
18.           
19.         //缓冲区的实质其实还是操作fileWriter对象，所以关闭缓冲区，就是关闭缓冲区的流对象，即fileWriter.close()  
20.         bufferedWriter.close();       
21.           
22.     }  

6、BufferedReader

从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。 可以指定缓冲区的大小，或者可使用默认的大小。

通常，Reader 所作的每个读取请求都会导致对底层字符或字节流进行相应的读取请求。因此，建议用 BufferedReader 包装所有其 read() 操作可能开销很高的 Reader（如 FileReader 和 InputStreamReader）。

将缓冲指定文件的输入。如果没有缓冲，则每次调用 read() 或 readLine() 都会导致从文件中读取字节，并将其转换为字符后返回，而这是极其低效的。 

下面是一个BufferedReader的简单练习，以及一些要点说明：

[java]  view plain copy

1. public static void bufferedReader() throws Exception{  
2.           
3.         Reader fileReader = null;  
4.         BufferedReader bufferedReader = null;  
5.         String spr = File.separator;  
6.         String result = null;  
7.           
8.         //实例化一个读取流对象和文件相关联  
9.         fileReader = new FileReader("G:" + spr + "TestFolder" + spr + "writer.txt");  
10.         //为了提高效率，加入缓冲技术。将字符读取流对象作为参数传递给缓冲对象的构造函数  
11.         bufferedReader = new BufferedReader(fileReader);  
12.           
13.         //该缓冲区提供了一次读一行的方法 readLine()，方便对文本文件数据的读取。  
14.         //当返回null时，表示读到文件末尾  
15.         while((result = bufferedReader.readLine()) != null){  
16.             P.rintln(result);  
17.         }  
18.         bufferedReader.close();  
19.     }  

7、通过缓冲区复制文本文件

ReadLine()无论是读一行，或者读取多个字符，其实最终使用的还是read()方法从硬盘一个一个读取。读取数据的时候不会将任何行终止符存入到缓冲区中，因此输出时不会换行，需要主动调用newLine()换行。
下面是一个简单的通过缓冲区复制文件的例子，已经一些要点说明：

[java]  view plain copy

1. public static void copyTextByBuf() throws Exception{  
2.           
3.         BufferedReader bufr = null;  
4.         BufferedWriter bufw = null;  
5.         String spr = File.separator;  
6.         String result = null;  
7.           
8.         bufr = new BufferedReader(new FileReader("G:" + spr + "TestFolder" + spr + "writer.txt"));  
9.         bufw = new BufferedWriter(new FileWriter("G:" + spr + "TestFolder" + spr + "writer_copy.txt"));  
10.           
11.         //readLine()返回的时候只返回回车符之前的数据内容，并不返回回车符  
12.         //因此输出的时候需要调用newLine()，以输出换行符  
13.         while((result = bufr.readLine()) != null){  
14.             bufw.write(result);  
15.             bufw.newLine();  
16.             bufw.flush();  
17.         }  
18.           
19.         bufw.close();  
20.         bufr.close();  
21.     }  

8、自定义一个BufferedReader

[java]  view plain copy

1. class MyBufferedReader{     //自定义一个缓冲流，等价于BufferedRrader  
2.       
3.     private Reader fileReader;  
4.       
5.     public MyBufferedReader(Reader fileReader){  
6.         this.fileReader = fileReader;  
7.     }  
8.       
9.     public String myReaderLine() throws IOException{    //读取一行数据  
10.           
11.         StringBuffer sb = new StringBuffer();  
12.         int value = 0;  
13.         while((value = fileReader.read()) != -1){  
14.             char ch = (char)value;  
15.             if(ch == '\r')  
16.                 continue;  
17.             if(ch == '\n')  
18.                 return sb.toString();  
19.             else  
20.                 sb.append(ch);  
21.         }  
22.         if(sb.length() != 0){  
23.             return sb.toString();  
24.         }  
25.         return null;  
26.     }  
27.       
28.     public void close() throws IOException{     //关闭流  
29.         fileReader.close();  
30.     }  
31.       
32. }  

9、装饰设计模式

装饰设计模式：当想要对已有的对象进行功能增强时，可以定义类，将已有对象传入，基于已有的功能，并提供加强的功能。那么自定义的该类称为装饰类。

装饰类通常会通过构造方法接收被装饰的对象，并基于被装饰的对象提供更强的功能。

装饰设计模式比继承要灵活，避免了继承体系臃肿，而且降低了类与类的关系。装饰类因为增强已有对象，具备的功能和已有的是相同的，只不过提供了更强功能。所以装饰类和被装饰类通常是都属于一个体系中的。

下面是一个使用装饰模式写的MyLineNumberReader类，可以显示行号：

[java]  view plain copy

1. class MyLineNumberReader extends MyBufferedReader{      //自建一个类，能显示行号  
2.       
3. //  private Reader in;  
4.     private int myLineNumber;  
5.       
6.     public MyLineNumberReader(Reader in) {  
7.         super(in);  
8. //      this.in = in;  
9.     }  
10.       
11.     public String myReadLine() throws IOException{  
12.           
13.         myLineNumber++;  
14.         return super.myReaderLine();  
15. //      StringBuffer sb = new StringBuffer();  
16. //      char c;  
17. //      int i;  
18. //        
19. //        
20. //      while((i = in.read()) != -1){  
21. //          c = (char)i;  
22. //          if(c == '\r')  
23. //              continue;  
24. //          if(c == '\n')  
25. //              return sb.toString();  
26. //          else  
27. //              sb.append(c);  
28. //      }  
29. //      if(sb.length() != 0)  
30. //          return sb.toString();  
31. //      return null;  
32.     }  
33.   
34.     public int getMyLineNumber() {  
35.         return myLineNumber;  
36.     }  
37.   
38.     public void setMyLineNumber(int myLineNumber) {  
39.         this.myLineNumber = myLineNumber;  
40.     }  
41.       
42. //  public void myClose() throws IOException{  
43. //      in.close();  
44. //  }  
45.       
46. }  

[java]  view plain copy

1. public static void myLineNumberReader() throws Exception{  
2.           
3.         String spr = File.separator;  
4.         FileReader fr = null;  
5.         MyLineNumberReader mlnr = null;  
6.         String line = null;  
7.           
8.         fr = new FileReader("G:" + spr + "Workspaces" + spr + "MyEclipse 9" + spr + "Study" +   
9.                 spr + "src" + spr + "com" + spr + "xgh" + spr + "itheima" + spr + "learn" + spr + "SystemAndOthers.java");  
10.         mlnr = new MyLineNumberReader(fr);  
11.         while((line = mlnr.myReadLine()) != null){  
12.             P.rintln(mlnr.getMyLineNumber() + ":" + line);  
13.         }  
14.         mlnr.close();  
15.     }