下班了，不想回去，小结一下。。。
传说很久以前的Java是不支持对文本文件的处理的，后来为了弥补这个遗憾而新引入了Reader和Writer两个抽象类。最常用的就是Writer中的write(char[] ch,int off,int length)/flush()/close()以及Reader中的read(char[] ch,int off,int length)和close()方法都是抽象方法。子类分别实现他们。例如：FileReader和FileWriter类。
简单的读取文本文件的内容可以这样实现：

 
  
  1. import java.io.FileReader;  
  2.    
  3.  public class Test {  
  4.      public static void main(String[] args) {  
  5.          try {  
  6.              FileReader fr = new FileReader("d://java.txt");  
  7.              int ch = 0;  
  8.              while ((ch = fr.read()) != -1) {  
  9.                  System.out.print((char) ch+"");            }  
  10.          } catch (Exception e) {  
  11.              e.printStackTrace();  
  12.              System.out.println("操作文件时候出问题了");  
  13.          }  
  14.      }  
  15.  } 
 
  
但是这样读出来的文件是按照字符读出来的，阅读起来不方便，可以增加判定条件，改为：
 
  
 
  
  1. import java.io.FileReader;  
  2.    
  3.  public class Test {  
  4.      public static void main(String[] args) {  
  5.          try {  
  6.              FileReader fr = new FileReader("d://java.txt");  
  7.    
  8.              int ch = 0;  
  9.              while ((ch = fr.read()) != -1) {  
  10.                  System.out.print((char) ch+"");  
  11.                  if(ch == 0){  
  12.                      System.out.println();  
  13.                  }  
  14.              }  
  15.          } catch (Exception e) {  
  16.              e.printStackTrace();  
  17.              System.out.println("操作文件时候出问题了");  
  18.          }  
  19.      }  
  20.  } 
 
  
其中，read方法返回读取到的下个字符，但是在上面的代码中实现按行读取还得做判断，岂不是很麻烦，所以，我们可以使用BufferedReader对Reader来进行封装，这样不仅可以按行读取文本内容（readLine()），还能提高读取速度。例如：
 
  
 
  
  1. <pre class="brush:java;gutter:true;">  
  2.  import java.io.BufferedReader;  
  3.  import java.io.FileInputStream;  
  4.  import java.io.InputStreamReader;  
  5.    
  6.  public class Test {  
  7.      public static void main(String[] args) {  
  8.          try {  
  9.              BufferedReader br =   
  10.                  new BufferedReader(new InputStreamReader(new FileInputStream("d://java.txt")));  
  11.              String data = "";  
  12.              while((data = br.readLine()) != null){  
  13.                  System.out.println(data);  
  14.              }  
  15.          } catch (Exception e) {  
  16.              e.printStackTrace();  
  17.              System.out.println("操作文件时候出问题了");  
  18.          }  
  19.      }  
  20.  } 
 
  
Reader是读取文件内容，那么很理所应当的Writer就是要向文件中写内容，但是在写文件的过程中，需要注意缓冲区的问题，这个是为了提高效率，但是在某些情况下可能会导致缓冲区未能正常刷新（例如下面的例子），这样就需要我们主动调用flush()方法刷新缓冲区：
 
  
 
  
  1. import java.io.FileWriter;  
  2.    
  3.  public class Test {  
  4.  public static void main(String[] args) {  
  5.  try {  
  6.  FileWriter fw = new FileWriter("d://c.txt");  
  7.  String data = "hello,Mr Shu!!!!";  
  8.  fw.write(data, 0, data.length());  
  9.  // fw.flush();  
  10.  } catch (Exception e) {  
  11.  e.printStackTrace();  
  12.  System.out.println("操作文件时候出问题了");  
  13.  }  
  14.  }  
  15.  } 
 
  
上面的代码执行后，c.txt中并没有数据，那是因为缓冲区未能正常刷新，可以去掉上面的fw.flush();前的注视。
 再看下面的程序：
 
  
 
  
  1. import java.io.FileWriter;  
  2.    
  3.  public class Test {  
  4.      public static void main(String[] args) {  
  5.          FileWriter fw = null;  
  6.          try {  
  7.              fw = new FileWriter("d://c.txt");  
  8.              String data = "hello,Mr Shu!!!!";  
  9.              fw.write(data, 0, data.length());  
  10.  //             fw.flush();  
  11.          } catch (Exception e) {  
  12.              e.printStackTrace();  
  13.              System.out.println("操作文件时候出问题了");  
  14.          } finally {  
  15.              try{  
  16.                  fw.close();  
  17.              }catch(Exception ex){  
  18.                  ex.printStackTrace();  
  19.                  System.out.println("系统好像出问题了");  
  20.              }  
  21.                
  22.          }  
  23.      }  
  24.  } 
 
  
注释掉了fw.flush();但是文件中却有内容，这就说明正常的关闭流是可以自动刷新缓冲区的。所以，一般情况下都尽可能地在必要的地方关闭文件流。
 未完待续…………