java基础之io流

本文部分转载之http://www.cnblogs.com/xdp-gacl/p/3634409.html

一、JAVA流式输入/输出原理

    流是用来读写数据的，java有一个类叫File，它封装的是文件的文件名，只是内存里面的一个对象，真正的文件是在硬盘上的一块空间，在这个文件里面存放着各种各样的数据，我们想读文件里面的数据怎么办呢？是通过一个流的方式来读，咱们要想从程序读数据，对于计算机来说，无论读什么类型的数据都是以010101101010这样的形式读取的。怎么把文件里面的数据读出来呢？你可以把文件想象成一个小桶，文件就是一个桶，文件里面的数据就相当于是这个桶里面的水，那么我们怎么从这个桶里面取水呢，也就是怎么从这个文件读取数据呢。

    常见的取水的办法是我们用一根管道插到桶上面，然后在管道的另一边打开水龙头，桶里面的水就开始哗啦哗啦地从水龙头里流出来了，桶里面的水是通过这根管道流出来的，因此这根管道就叫流，JAVA里面的流式输入/输出跟水流的原理一模一样，当你要从文件读取数据的时候，一根管道插到文件里面去，然后文件里面的数据就顺着管道流出来，这时你在管道的另一头就可以读取到从文件流出来的各种各样的数据了。当你要往文件写入数据时，也是通过一根管道，让要写入的数据通过这根管道哗啦哗啦地流进文件里面去。除了从文件去取数据以外，还可以通过网络，比如用一根管道把我和你的机子连接起来，我说一句话，通过这个管道流进你的机子里面，你马上就可以看得到，而你说一句话，通过这根管道流到我的机子里面，我也马上就可以看到。有的时候，一根管道不够用，比方说这根管道流过来的水有一些杂质，我们就可以在这个根管道的外面再包一层管道，把杂质给过滤掉。从程序的角度来讲，从计算机读取到的原始数据肯定都是010101这种形式的，一个字节一个字节地往外读，当你这样读的时候你觉得这样的方法不合适，没关系，你再在这根管道的外面再包一层比较强大的管道，这个管道可以把010101帮你转换成字符串。这样你使用程序读取数据时读到的就不再是010101这种形式的数据了，而是一些可以看得懂的字符串了。

二、输入输出流分类

io包里面定义了所有的流，所以一说流指的就是io包里面的

　　什么叫输入流？什么叫输出流？用一根管道一端插进文件里程序里面，然后开始读数据，那么这是输入还是输出呢？如果站在文件的角度上，这叫输出，如果站在程序的角度上，这叫输入。

　　记住，以后说输入流和输出流都是站在程序的角度上来说。

       字节流和字符流选择

       字节流：字节流读取的时候，读到一个字节就返回一个字节；  主要用于读取图片，MP3，AVI视频文件。

       字符流：字符流使用了字节流读到一个或多个字节，如读取中文时，就会一次读取2个字节。只要是处理纯文本数据，就要优先考虑使用字符流。

三、节点流和处理流

你要是对原始的流不满意，你可以在这根管道外面再套其它的管道，套在其它管道之上的流叫处理流。为什么需要处理流呢？这就跟水流里面有杂质，你要过滤它，你可以再套一层管道过滤这些杂质一样。

1. 节点流：可以从或向一个特定的地方（节点）读写数据。如FileReader.
2. 处理流：是对一个已存在的流的连接和封装，通过所封装的流的功能调用实现数据读写。如BufferedReader.处理流的构造方法总是要带一个其他的流对象做参数。一个流对象经过其他流的多次包装，称为流的链接。
3. 总结：通常在IO的继承树中，继承自Filter开头的流或者转化流都是处理流，其他的都是节点流。

3.1.节点流类型

　　

　　节点流就是一根管道直接插到数据源上面，直接读数据源里面的数据，或者是直接往数据源里面写入数据。典型的节点流是文件流：文件的字节输入流（FileInputStream），文件的字节输出流（FileOutputStream），文件的字符输入流（FileReader），文件的字符输出流（FileWriter）。

3.2.处理流类型

　　

　　处理流是包在别的流上面的流，相当于是包到别的管道上面的管道。

四、InputStream(输入流)

　　

　　我们看到的具体的某一些管道，凡是以InputStream结尾的管道，都是以字节的形式向我们的程序输入数据。

4.1.InputStream的基本方法

　　

 　　read()方法是一个字节一个字节地往外读，每读取一个字节，就处理一个字节。read(byte[] buffer)方法读取数据时，先把读取到的数据填满这个byte[]类型的数组buffer(buffer是内存里面的一块缓冲区)，然后再处理数组里面的数据。这就跟我们取水一样，先用一个桶去接，等桶接满水后再处理桶里面的水。如果是每读取一个字节就处理一个字节，这样子读取也太累了。

五、OutputStream(输出流)

　　

5.1.OutputStream的基本方法

　　

六、Reader流

　　

6.1.Reader的基本方法

　　

七、Writer流

　　

7.1.Writer的基本方法

　　

八、节点流讲解

　　以File(文件)这个类型作为讲解节点流的典型代表

　　

范例：使用FileInputStream流来读取FileInputStream.java文件的内容，使用FileOutputStream流往一个文件里面写入数据

[java]  view plain  copy

1. public static void main(String args[]) {  
2. int b = 0;  
3. FileInputStream in = null;  
4. FileOutputStream out = null;  
5. try {  
6.     // 使用FileInputStream流来读取有中文的内容时，读出来的是乱码，因为使用InputStream流里面的read()方法读取内容时是一个字节一个字节地读取的，而一个汉字是占用两个字节的，所以读取出来的汉字无法正确显示。  
7.     // FileReader in = null;//使用FileReader流来读取内容时，中英文都可以正确显示，因为Reader流里面的read()方法是一个字符一个字符地读取的，这样每次读取出来的都是一个完整的汉字，这样就可以正确显示了。  
8.     in = new FileInputStream("D:\\Java\\MyMouseAdapter.java");  
9.     out = new FileOutputStream("D:/java/TestFileOutputStream1.java");  
10.     // 指明要写入数据的文件，如果指定的路径中不存在TestFileOutputStream1.java这样的文件，则系统会自动创建一个  
11.     while ((b = in.read()) != -1) {  
12.     // 调用int read() throws Exception方法时，返回的是一个int类型的整数  
13.         // 循环结束的条件就是返回一个值-1，表示此时已经读取到文件的末尾了。  
14.         // System.out.print(b+"\t");//如果没有使用“(char)b”进行转换，那么直接打印出来的b就是数字，而不是英文和中文了  
15.         out.write(b);// 调用write(int c)方法把读取到的字符全部写入到指定文件中去  
16.     }  
17.     in.close();  
18.     out.close();  
19. } catch (FileNotFoundException e) {  
20.     System.out.println("文件读取失败");  
21.     System.exit(-1);// 非正常退出  
22. } catch (IOException e1) {  
23.     System.out.println("文件复制失败！");  
24.     System.exit(-1);  
25. }  
26. System.out.println("TestFileInputStream.java文件里面的内容已经成功复制到文件TestFileOutStream1.java里面");  
27. }  

FileInputStream和FileOutputStream这两个流都是字节流，都是以一个字节为单位进行输入和输出的。所以对于占用2个字节存储空间的字符来说读取出来时就会显示成乱码。

范例：使用FileWriter（字符流）向指定文件中写入数据，使用FileReader读取文件数据

[java]  view plain  copy

1. /*使用FileWriter（字符流）向指定文件中写入数据 
2. 写入数据时以1个字符为单位进行写入*/  
3. public class TestFileWriter{  
4.     public static void main(String args[]){  
5.         /*使用FileWriter输出流从程序把数据写入到Uicode.dat文件中 
6.         使用FileWriter流向文件写入数据时是一个字符一个字符写入的*/  
7.         FileWriter fw = null;  
8.         try{  
9.                 fw = new FileWriter("D:/java/Uicode.dat");  
10.                 //字符的本质是一个无符号的16位整数  
11.                 //字符在计算机内部占用2个字节  
12.                 //这里使用for循环把0～60000里面的所有整数都输出  
13.                 //这里相当于是把全世界各个国家的文字都0～60000内的整数的形式来表示  
14.                 for(int c=0;c<=60000;c++){  
15.                     fw.write(c);  
16.                     //使用write(int c)把0～60000内的整数写入到指定文件内  
17.                     //调用write()方法时，我认为在执行的过程中应该使用了“(char)c”进行强制转换，即把整数转换成字符来显示  
18.                     //因为打开写入数据的文件可以看到，里面显示的数据并不是0～60000内的整数，而是不同国家的文字的表示方式  
19.             }  
20.             /*使用FileReader(字符流)读取指定文件里面的内容 
21.             读取内容时是以一个字符为单位进行读取的*/  
22.                 int b = 0;  
23.                 long num = 0;  
24.                 FileReader fr = null;  
25.                 fr = new FileReader("D:/java/Uicode.dat");  
26.                 while((b = fr.read())!= -1){  
27.                     System.out.print((char)b + "\t");  
28.                     num++;  
29.                 }  
30.                 System.out.println();  
31.                 System.out.println("总共读取了"+num+"个字符");  
32.         }catch(Exception e){  
33.             e.printStackTrace();  
34.         }  
35.     }  
36. }  

FileReader和FileWriter这两个流都是字符流，都是以一个字符为单位进行输入和输出的。所以读取和写入占用2个字节的字符时都可以正常地显示出来，以上是以File(文件)这个类型为例对节点流进行了讲解，所谓的节点流指定就是直接把输入流或输出插入到数据源上，直接往数据源里面写入数据或读取数据。

九、处理流讲解

9.1.第一种处理流——缓冲流(Buffering)

　　　

　　带有缓冲区的，缓冲区(Buffer)就是内存里面的一小块区域，读写数据时都是先把数据放到这块缓冲区域里面，减少io对硬盘的访问次数，保护我们的硬盘。可以把缓冲区想象成一个小桶，把要读写的数据想象成水，每次读取数据或者是写入数据之前，都是先把数据装到这个桶里面，装满了以后再做处理。这就是所谓的缓冲。先把数据放置到缓冲区上，等到缓冲区满了以后，再一次把缓冲区里面的数据写入到硬盘上或者读取出来，这样可以有效地减少对硬盘的访问次数，有利于保护我们的硬盘。

测试缓存流代码

[java]  view plain  copy

1. public static void main(String args[]){  
2.     try{  
3.     BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\java\\dat.txt"));  
4.         //在节点流FileWriter的外面再套一层处理流BufferedWriter  
5.         String s = null;  
6.         for(int i=0;i<100;i++){  
7.             s = String.valueOf(Math.random());//“Math.random()”将会生成一系列介于0～1之间的随机数。  
8.             // static String valueOf(double d)这个valueOf()方法的作用就是把一个double类型的数转换成字符串  
9.             //valueOf()是一个静态方法，所以可以使用“类型.静态方法名”的形式来调用   
10.             bw.write(s);//把随机数字符串写入到指定文件中  
11.             bw.newLine();//调用newLine()方法使得每写入一个随机数就换行显示  
12.         }  
13.         bw.flush();//调用flush()方法清空缓冲区  
14.           
15.     BufferedReader br = new BufferedReader(new FileReader("D:/java/dat.txt"));  
16.             //在节点流FileReader的外面再套一层处理流BufferedReader  
17.         while((s = br.readLine())!=null){  
18.             //使用BufferedReader处理流里面提供String readLine()方法读取文件中的数据时是一行一行读取的  
19.             //循环结束的条件就是使用readLine()方法读取数据返回的字符串为空值后则表示已经读取到文件的末尾了。  
20.             System.out.println(s);  
21.         }  
22.     bw.close();  
23.     br.close();  
24.     }catch(Exception e){  
25.         e.printStackTrace();  
26.     }  
27. }  

　　程序的输入指的是把从文件读取到的内容存储到为程序分配的内存区域里面去。流，什么是流，流无非就是两根管道，一根向里，一根向外，向里向外都是对于我们自己写的程序来说，流分为各种各样的类型，不同的分类方式又可以分为不同的类型，根据方向来分，分为输入流和输出流，根据读取数据的单位的不同，又可以分为字符流和字节流，除此之外，还可以分为节点流和处理流，节点流就是直接和数据源连接的流，处理流就是包在其它流上面的流，处理流不是直接和数据源连接，而是从数据源读取到数据以后再通过处理流处理一遍。缓冲流也包含了四个类：BufferedInputStream、BufferedOutputStream、BufferedReader和BufferedWriter。流都是成对的，没有流是是不成对的，肯定是一个in，一个out。

9.2.第二种处理流——转换流

　　转换流非常的有用，它可以把一个字节流转换成一个字符流，转换流有两种，一种叫InputStreamReader，另一种叫OutputStreamWriter。InputStream是字节流，Reader是字符流，InputStreamReader就是把InputStream转换成Reader。OutputStream是字节流，Writer是字符流，OutputStreamWriter就是把OutputStream转换成Writer。把OutputStream转换成Writer之后就可以一个字符一个字符地通过管道写入数据了，而且还可以写入字符串。我们如果用一个FileOutputStream流往文件里面写东西，得要一个字节一个字节地写进去，但是如果我们在FileOutputStream流上面套上一个字符转换流，那我们就可以一个字符串一个字符串地写进去。

转换流测试代码：

[java]  view plain  copy

1. public static void main(String args[]) {  
2.     try {  
3.         OutputStreamWriter osw = new OutputStreamWriter(  
4.                 new FileOutputStream("D:/java/char.txt"));  
5.         // 把字符串写入到指定的文件中去  
6.         osw.write("MircosoftsunIBMOracleApplet");  
7.         // 使用getEncoding()方法取得当前系统的默认字符编码  
8.         System.out.println(osw.getEncoding());  
9.         osw.close();  
10.         /*如果在调用FileOutputStream的构造方法时没有加入true 
11.         那么新加入的字符串就会替换掉原来写入的字符串 
12.         在调用构造方法时指定了字符的编码*/  
13.         osw = new OutputStreamWriter(new FileOutputStream(  
14.                 "D:\\java\\char.txt", true), "ISO8859_1");  
15.         // 再次向指定的文件写入字符串，新写入的字符串加入到原来字符串的后面  
16.         osw.write("MircosoftsunIBMOracleApplet");  
17.         System.out.println(osw.getEncoding());  
18.         osw.close();  
19.     } catch (Exception e) {  
20.         e.printStackTrace();  
21.     }  
22. }  

[java]  view plain  copy

1. public static void main(String args[]){  
2.         try{  
3.             InputStreamReader isr = new InputStreamReader(System.in);  
4.             //System.in这里的in是一个标准的输入流，用来接收从键盘输入的数据  
5.             BufferedReader br = new BufferedReader(isr);  
6.             String s = null;  
7.             s = br.readLine();//使用readLine()方法把读取到的一行字符串保存到字符串变量s中去  
8.             while(s != null){  
9.                 System.out.println(s.toUpperCase());//把保存在内存s中的字符串打印出来  
10.                 s = br.readLine();//在循环体内继续接收从键盘的输入  
11.                 if(s.equalsIgnoreCase("exit")){  
12.                     //只要输入exit循环就结束，就会退出  
13.                     break;  
14.                 }  
15.             }  
16.         }catch(Exception e){  
17.             e.printStackTrace();  
18.         }  
19.     }  

9.3.第三种处理流——数据流

　　

数据流测试代码：

[java]  view plain  copy

1. public static void main(String args[]){  
2.         ByteArrayOutputStream baos = new ByteArrayOutputStream();  
3.         //在调用构造方法时，首先会在内存里面创建一个ByteArray字节数组  
4.         DataOutputStream dos = new DataOutputStream(baos);  
5.         //在输出流的外面套上一层数据流，用来处理int，double类型的数  
6.         try{  
7.             dos.writeDouble(Math.random());//把产生的随机数直接写入到字节数组ByteArray中  
8.             dos.writeBoolean(true);//布尔类型的数据在内存中就只占一个字节  
9.         ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());  
10.             System.out.println(bais.available());  
11.             DataInputStream dis = new DataInputStream(bais);  
12.             System.out.println(dis.readDouble());//先写进去的就先读出来，调用readDouble()方法读取出写入的随机数  
13.             System.out.println(dis.readBoolean());//后写进去的就后读出来，这里面的读取顺序不能更改位置，否则会打印出不正确的结果  
14.             dos.close();  
15.             bais.close();  
16.         }catch(Exception e){  
17.                 e.printStackTrace();  
18.             }  
19.     }  

通过bais这个流往外读取数据的时候，是一个字节一个字节地往外读取的，因此读出来的数据无法判断是字符串还是bool类型的值，因此要在它的外面再套一个流，通过dataInputStream把读出来的数据转换就可以判断了。注意了：读取数据的时候是先写进去的就先读出来，因此读ByteArray字节数组数据的顺序应该是先把占8个字节的double类型的数读出来，然后再读那个只占一个字节的boolean类型的数，因为double类型的数是先写进数组里面的，读的时候也要先读它。这就是所谓的先写的要先读。如果先读Boolean类型的那个数，那么读出来的情况可能就是把double类型数的8个字节里面的一个字节读了出来。 

9.4.打印流——Print

测试代码：

9.5. 对象流——Object

　　

测试代码：

[java]  view plain  copy

1. package cn.gacl.test;  
2. import java.io.*;  
3. public class TestObjectIo {  
4.     public static void main(String args[]) {  
5.         T t = new T();  
6.         t.k = 8;// 把k的值修改为8  
7.         try {  
8.             FileOutputStream fos = new FileOutputStream(  
9.                     "D:/java/TestObjectIo.txt");  
10.             ObjectOutputStream oos = new ObjectOutputStream(fos);  
11.             // ObjectOutputStream流专门用来处理Object的，在fos流的外面套接ObjectOutputStream流就可以直接把一个Object写进去  
12.             oos.writeObject(t);// 直接把一个t对象写入到指定的文件里面  
13.             oos.flush();  
14.             oos.close();  
15.             FileInputStream fis = new FileInputStream(  
16.                     "D:/java/TestObjectIo.txt");  
17.             ObjectInputStream ois = new ObjectInputStream(fis);  
18.             // ObjectInputStream专门用来读一个Object的  
19.             T tRead = (T) ois.readObject();  
20.             // 直接把文件里面的内容全部读取出来然后分解成一个Object对象，并使用强制转换成指定类型T  
21.             System.out.print(tRead.i + "\t" + tRead.j + "\t" + tRead.d + "\t"  
22.                     + tRead.k);  
23.             ois.close();  
24.         } catch (Exception e) {  
25.             e.printStackTrace();  
26.         }  
27.     }  
28. }  
29. /* 
30.  * 凡是要将一个类的对象序列化成一个字节流就必须实现Serializable接口 
31.  * Serializable接口中没有定义方法，Serializable接口是一个标记性接口，用来给类作标记，只是起到一个标记作用。 
32.  * 这个标记是给编译器看的，编译器看到这个标记之后就可以知道这个类可以被序列化 如果想把某个类的对象序列化，就必须得实现Serializable接口 
33.  */  
34. class T implements Serializable {  
35.     // Serializable的意思是可以被序列化的  
36.     int i = 10;  
37.     int j = 9;  
38.     double d = 2.3;  
39.     int k = 15;  
40.     // transient int k = 15;  
41.     // 在声明变量时如果加上transient关键字，那么这个变量就会被当作是透明的，即不存在。  
42. }  

直接实现Serializable接口的类是JDK自动把这个类的对象序列化，而如果实现public interface Externalizable extends Serializable的类则可以自己控制对象的序列化，建议能让JDK自己控制序列化的就不要让自己去控制。

十、IO流总结

十一、文件读取与写入

[java]  view plain  copy

1. <strong>文件的读取和写入  
2. 第一组</strong>  
3. 1. 文件的读取（节点流FileInputStream读取字节流）  
4. 1.  public static void readFileByBytes(String fileName) {    
5. 2.      // 一般先创建file对象    
6. 3.      FileInputStream fileInput = null;    
7. 4.      try {    
8. 5.          File file = new File(fileName);    
9. 6.          if (!file.exists()) {    
10. 7.              file.createNewFile();    
11. 8.          }    
12. 9.          byte[] buffer = new byte[1024];    
13. 10.         fileInput = new FileInputStream(file);    
14. 11.         int byteread = 0;    
15. 12.         // byteread表示一次读取到buffers中的数量。    
16. 13.         while ((byteread = fileInput.read(buffer)) != -1) {    
17. 14.             System.out.write(buffer, 0, byteread);    
18. 15.         }    
19. 16.     } catch (Exception e) {    
20. 17.         // TODO: handle exception    
21. 18.     } finally {    
22. 19.         try {    
23. 20.             if (fileInput != null) {    
24. 21.                 fileInput.close();    
25. 22.             }    
26. 23.         } catch (IOException e) {    
27. 24.             // TODO Auto-generated catch block    
28. 25.             e.printStackTrace();    
29. 26.         }    
30. 27.     }    
31. 28. }    
32. 4.向文件中写入数据（字节流FileOutputStream）  
33. 1.  public void writeByFileOutputStream() {    
34. 2.      
35. 3.          FileOutputStream fop = null;    
36. 4.          File file;    
37. 5.          String content = "This is the text content";    
38. 6.          try {    
39. 7.              file = new File("c:/newfile.txt");    
40. 8.              fop = new FileOutputStream(file);    
41. 9.              // if file doesnt exists, then create it    
42. 10.             if (!file.exists()) {    
43. 11.                 file.createNewFile();    
44. 12.             }    
45. 13.             // get the content in bytes    
46. 14.             byte[] contentInBytes = content.getBytes();    
47. 15.             fop.write(contentInBytes);    
48. 16.             fop.flush();    
49. 17.             fop.close();    
50. 18.     
51. 19.         } catch (IOException e) {    
52. 20.             e.printStackTrace();    
53. 21.         } finally {    
54. 22.             try {    
55. 23.                 if (fop != null) {    
56. 24.                     fop.close();    
57. 25.                 }    
58. 26.             } catch (IOException e) {    
59. 27.                 e.printStackTrace();    
60. 28.             }    
61. 29.         }    
62. 30.     }    
63.    
64. <strong>第二组</strong>  
65. 2. 文件读取（节点流FileReader读取字符流）  
66. 1.  public static void readFileByChars(String fileName) {    
67. 2.          FileReader reader = null;    
68. 3.          try {    
69. 4.              File file = new File(fileName);    
70. 5.              if (!file.exists()) {    
71. 6.                  file.createNewFile();    
72. 7.              }    
73. 8.              reader = new FileReader(file);    
74. 9.              char[] buffer = new char[1024];    
75. 10.             int charread = 0;    
76. 11.             while ((charread = reader.read(buffer)) != -1) {    
77. 12.                 System.out.print(buffer);    
78. 13.             }    
79. 14.         } catch (IOException e) {    
80. 15.             // TODO: handle exception    
81. 16.         } finally {    
82. 17.             try {    
83. 18.                 if (reader != null) {    
84. 19.                     reader.close();    
85. 20.                 }    
86. 21.             } catch (IOException e) {    
87. 22.                 // TODO Auto-generated catch block    
88. 23.                 e.printStackTrace();    
89. 24.             }    
90. 25.         }    
91. 26.     }    
92.  其实FileReader也是需要FileInputStream对象转换的，要借助于InputStreamReader转换流。  
93. 5. 向文件中写数据（FileReader）【注意使用FileReader（“path”，true）可以往文件后面追加内容，否则就直接覆盖了】  
94. 1.  public static void writeByFileReader() {    
95. 2.          try {    
96. 3.              String data = " This content will append to the end of the file";    
97. 4.              File file = new File("javaio-appendfile.txt");    
98. 5.              // if file doesnt exists, then create it    
99. 6.              if (!file.exists()) {    
100. 7.                  file.createNewFile();    
101. 8.              }    
102. 9.              // true = append file    
103. 10.             FileWriter fileWritter = new FileWriter(file.getName(), true);    
104. 11.             fileWritter.write(data);    
105. 12.             fileWritter.close();    
106. 13.         } catch (IOException e) {    
107. 14.             e.printStackTrace();    
108. 15.         }    
109. 16.     }    
110. <strong>第三组</strong>  
111. 3.文件的读取通过BufferedReader读取数据。  
112. 1.  public static void readByBufferedReader(String fileName) {    
113. 2.          try {    
114. 3.              File file = new File(fileName);    
115. 4.              // 读取文件，并且以utf-8的形式写出去    
116. 5.              BufferedReader bufread;    
117. 6.              String read;    
118. 7.              bufread = new BufferedReader(new FileReader(file));    
119. 8.              while ((read = bufread.readLine()) != null) {    
120. 9.                  System.out.println(read);    
121. 10.             }    
122. 11.             bufread.close();    
123. 12.         } catch (FileNotFoundException ex) {    
124. 13.             ex.printStackTrace();    
125. 14.         } catch (IOException ex) {    
126. 15.             ex.printStackTrace();    
127. 16.         }    
128. 17.     }    
129. 6.采用BufferedWriter向文件中写数据  
130. 1.  public static void writeByBufferedReader() {    
131. 2.          try {    
132. 3.              String content = "This is the content to write into file";    
133. 4.              File file = new File("/users/mkyong/filename.txt");    
134. 5.              // if file doesnt exists, then create it    
135. 6.              if (!file.exists()) {    
136. 7.                  file.createNewFile();    
137. 8.              }    
138. 9.              FileWriter fw = new FileWriter(file, true);    
139. 10.             BufferedWriter bw = new BufferedWriter(fw);    
140. 11.             bw.write(content);    
141. 12.             bw.flush();    
142. 13.             bw.close();    
143. 14.         } catch (IOException e) {    
144. 15.             e.printStackTrace();    
145. 16.         }    
146. 17.     }    

[html]  view plain  copy

1. 总结：使用io来操作文件比较多一些，一般都喜欢用BufferedReader和BufferedWriter，  
2. 使用它们的一般流程是，先创建File对象（可以对路径和文件进行更多的操作），  
3. 然后通过File对象创建FileReader（FileWriter）【也可以通过创建InputStreamReader（new InputStream）来获取reader对象】，  
4. 然后通过FileReader（FileWriter）获得BufferedReader（BufferedWriter）对象。  
5. 对于读入文件，还可以使用Scanner对读取的文件进行操作，这个比较方便，Scanner也是处理流，因此也是需要节点流作为其参数的。