字节输入输出流：

1. FileInputStream fis = new FileInputStream(filePath); 
2. FileOutputStream fos = new FileOutputStream(savePath); 
3.  
4. byte[] buffer = new byte[1024]; 
5. int length = 0; 
6. while (-1 != (length = fis.read(buffer))) 
7. { 
8. fos.write(buffer); 
9. /** 
10.   * 等价于下面的写法： 
11.   * String str = new String(buffer, 0, length); 
12.   * fos.write(str.getBytes()); 
13.   */ 
14. } 

 

字符输入输出流：

1. FileReader fr = new FileReader(fileName);  
2. char[] buffer = new char[1024];//使用字符数组  
3. int length = 0;  
4. while (-1 != (length = fr.read(buffer)))  
5. {  
6.     for (int i = 0; i < length; i++)  
7.     {  
8.         System.out.print(buffer[i]);  
9.     }  
10. }  
11.  
12.  
13. FileWriter fw = new FileWriter(fileName); 
14. fw.write("这段字符串按字符写入good"); 
15. fw.flush();//写完清空缓存 

 

转换流、缓冲流：

1. FileInputStream fis = new FileInputStream(fileName); 
2. InputStreamReader isr = new InputStreamReader(fis); 
3. BufferedReader br = new BufferedReader(isr); 
4.  
5. FileOutputStream fos = new FileOutputStream(saveName); 
6. OutputStreamWriter osw = new OutputStreamWriter(fos); 
7. BufferedWriter bw = new BufferedWriter(osw); 
8.  
9.  
10. String str = null; 
11. while (null != (str = br.readLine()))//读取每行直到'\r'或'\t'则为空 
12. { 
13.     bw.write(str);//write可以写入字符串或者字符 
14.     bw.newLine();//换行 
15.     bw.flush();//清空缓存 
16. } 

文件拷贝方法：练习字节流、字符流、缓冲流、转换流

1. public class CopyMethod 
2. { 
3.     public static void main(String[] args) 
4.     { 
5.         CopyMethod cm = new CopyMethod(); 
6.         String scr = "F:/java/tt.txt"; 
7.         String dest = "F:/java/xx.txt"; 
8.         cm.copyMethod(scr, dest); 
9.     } 
10.      
11.     public void copyMethod(String scr,String dest) 
12.     { 
13.         BufferedReader fr = null; 
14.         BufferedWriter bw = null; 
15.         try 
16.         { 
17.             FileInputStream fis = new FileInputStream(scr);//文件输入流 
18.             InputStreamReader isr = new InputStreamReader(fis);//转换流，将字节流转换为字符流 
19.             fr = new BufferedReader(isr);//创建字符缓冲流，每次读取一行字符 
20.              
21.             FileOutputStream fos = new FileOutputStream(dest); 
22.             OutputStreamWriter osw = new OutputStreamWriter(fos); 
23.             bw = new BufferedWriter(osw); 
24.              
25.             String str = null;//缓冲流读取和写入的都是字符串 
26.             while(null != (str = fr.readLine()))//使用readLine()，读取到\r或\n结束 
27.             { 
28.                 bw.write(str);//写入一行字符串 
29.                 bw.newLine();//换行 
30.                 bw.flush();//清空缓存,使用writer需要flush 
31.             } 
32.         } 
33.         catch (FileNotFoundException e) 
34.         { 
35.             e.printStackTrace(); 
36.         } 
37.         catch (IOException e) 
38.         { 
39.             e.printStackTrace(); 
40.         } 
41.         finally//关闭最外层的流 
42.         { 
43.             if(fr != null) 
44.             { 
45.                 try 
46.                 { 
47.                     fr.close(); 
48.                 } 
49.                 catch (IOException e) 
50.                 { 
51.                     e.printStackTrace(); 
52.                 } 
53.             } 
54.             if(null != bw) 
55.             { 
56.                 try 
57.                 { 
58.                     bw.close(); 
59.                 } 
60.                 catch (IOException e) 
61.                 { 
62.                     e.printStackTrace(); 
63.                 } 
64.             } 
65.         } 
66.     } 
67. } 

 

本文转自 glblong 51CTO博客，原文链接：http://blog.51cto.com/glblong/1191870，如需转载请自行联系原作者