1. package cn.itcast.day21;
   
2. 
   
3. import java.io.BufferedInputStream;
   
4. import java.io.BufferedOutputStream;
   
5. import java.io.BufferedReader;
   
6. import java.io.BufferedWriter;
   
7. import java.io.FileInputStream;
   
8. import java.io.FileOutputStream;
   
9. import java.io.FileReader;
   
10. import java.io.FileWriter;
    
11. import java.io.IOException;
    
12. 
    
13. /*
    
14. * 九种复制方法
    
15. */
    
16. public class Demo_nine_Copy {
    
17. 
    
18. 
    
19. 
    
20.         public static void main(String[] args) throws IOException {
    
21.                 long currentTimeMillis = System.currentTimeMillis();
    
22.                 method1();
    
23.                 long currentTimeMillis2 = System.currentTimeMillis();
    
24.                 method2();
    
25.                 long currentTimeMillis3 = System.currentTimeMillis();
    
26.                 method3();
    
27.                 long currentTimeMillis4 = System.currentTimeMillis();
    
28.                 method4();
    
29.                 long currentTimeMillis5 = System.currentTimeMillis();
    
30.                 method5();
    
31.                 long currentTimeMillis6 = System.currentTimeMillis();
    
32.                 method6();
    
33.                 long currentTimeMillis7 = System.currentTimeMillis();
    
34.                 method7();
    
35.                 long currentTimeMillis8 = System.currentTimeMillis();
    
36.                 method8();
    
37.                 long currentTimeMillis9 = System.currentTimeMillis();
    
38.                 method9();
    
39.                 long currentTimeMillis10 = System.currentTimeMillis();
    
40.                 System.out.println("普通字节流  一次一个字节:      "+(currentTimeMillis2-currentTimeMillis));
    
41.                 System.out.println("普通字节流  一次一个字节数组:  "+(currentTimeMillis3-currentTimeMillis2));
    
42.                 System.out.println("高效字节流  一次一个字节:      "+(currentTimeMillis4-currentTimeMillis3));
    
43.                 System.out.println("高效字节流  一次一个字节数组:  "+(currentTimeMillis5-currentTimeMillis4));
    
44.                 System.out.println("普通字符流  一次一个字符:      "+(currentTimeMillis6-currentTimeMillis5));
    
45.                 System.out.println("普通字符流  一次一个字符数组:  "+(currentTimeMillis7-currentTimeMillis6));
    
46.                 System.out.println("高效字节流  一次一个字符数组:  "+(currentTimeMillis8-currentTimeMillis7));
    
47.                 System.out.println("高效字节流  一次一个字符:     "+(currentTimeMillis9-currentTimeMillis8));
    
48.                 System.out.println("高效字节流  一次一行:         "+(currentTimeMillis10-currentTimeMillis9));
    
49.                
    
50.         }
    
51.         //普通字节流  一次一个字节
    
52.         public static void method1() throws IOException{
    
53.                 FileInputStream fis = new FileInputStream("c.txt");
    
54.                 FileOutputStream fos = new FileOutputStream("d.txt");
    
55.                
    
56.                 int b=0;
    
57.                 while((b=fis.read())!=-1){
    
58.                         fos.write(b);
    
59.                 }
    
60.                 fos.close();
    
61.                 fis.close();
    
62.         }
    
63.         //普通字节流  一次一个字节数组
    
64.         public static void method2() throws IOException{
    
65.                 FileInputStream fis = new FileInputStream("c.txt");
    
66.                 FileOutputStream fos = new FileOutputStream("d.txt");
    
67.                
    
68.                 int len=0;
    
69.                 byte[] bytes = new byte[1024];
    
70.                 while((len=fis.read(bytes))!=-1){
    
71.                         fos.write(bytes,0,len);
    
72.                 }
    
73.                 fos.close();
    
74.                 fis.close();
    
75.         }
    
76.         //高效字节流  一次一个字节
    
77.         public static void method3() throws IOException{
    
78.                 FileInputStream fis = new FileInputStream("c.txt");
    
79.                 FileOutputStream fos = new FileOutputStream("d.txt");
    
80.                 BufferedInputStream bis = new BufferedInputStream(fis);
    
81.                 BufferedOutputStream bos = new BufferedOutputStream(fos);
    
82.                 int b=0;
    
83.                 while((b=bis.read())!=-1){
    
84.                         bos.write(b);
    
85.                 }
    
86.                 bos.close();
    
87.                 bis.close();
    
88.         }
    
89.         //高效字节流  一次一个字节数组
    
90.         public static void method4() throws IOException{
    
91.                 FileInputStream fis = new FileInputStream("c.txt");
    
92.                 FileOutputStream fos = new FileOutputStream("d.txt");
    
93.                 BufferedInputStream bis = new BufferedInputStream(fis);
    
94.                 BufferedOutputStream bos = new BufferedOutputStream(fos);
    
95.                 int len=0;
    
96.                 byte[] bytes = new byte[1024];
    
97.                 while((len=bis.read(bytes))!=-1){
    
98.                         bos.write(bytes,0,len);
    
99.                 }
    
100.                 bos.close();
     
101.                 bis.close();
     
102.         }
     
103.         //普通字符流  一次一个字符
     
104.                 public static void method5() throws IOException{
     
105.                         FileReader fis = new FileReader("c.txt");
     
106.                         FileWriter fos = new FileWriter("d.txt");
     
107.                        
     
108.                         int b=0;
     
109.                         while((b=fis.read())!=-1){
     
110.                                 fos.write(b);
     
111.                         }
     
112.                         fos.close();
     
113.                         fis.close();
     
114.                 }
     
115.                 //普通字符流  一次一个字符数组
     
116.                 public static void method6() throws IOException{
     
117.                         FileReader fis = new FileReader("c.txt");
     
118.                         FileWriter fos = new FileWriter("d.txt");
     
119.                        
     
120.                         int len = 0;
     
121.                         char[] bytes = new char[1024];
     
122.                         while((len=fis.read(bytes))!=-1){
     
123.                                 fos.write(bytes,0,len);
     
124.                         }
     
125.                         fos.close();
     
126.                         fis.close();
     
127.                 }
     
128.                 //高效字符流  一次一个字符数组
     
129.                 public static void method7() throws IOException{
     
130.                         FileReader fis = new FileReader("c.txt");
     
131.                         FileWriter fos = new FileWriter("d.txt");
     
132.                         BufferedReader br = new BufferedReader(fis);
     
133.                         BufferedWriter bw = new BufferedWriter(fos);
     
134.                         int len = 0;
     
135.                         char[] bytes = new char[1024];
     
136.                         while((len=br.read(bytes))!=-1){
     
137.                                 bw.write(bytes,0,len);
     
138.                         }
     
139.                         bw.close();
     
140.                         br.close();
     
141.                 }
     
142.                 //高效字符流  一次一个字符
     
143.                 public static void method8() throws IOException{
     
144.                         FileReader fis = new FileReader("c.txt");
     
145.                         FileWriter fos = new FileWriter("d.txt");
     
146.                         BufferedReader br = new BufferedReader(fis);
     
147.                         BufferedWriter bw = new BufferedWriter(fos);
     
148.                         int b = 0;
     
149.                        
     
150.                         while((b=br.read())!=-1){
     
151.                                 bw.write(b);
     
152.                         }
     
153.                         bw.close();
     
154.                         br.close();
     
155.                 }
     
156.                 //高效字符流  一次一行
     
157.                 public static void method9() throws IOException{
     
158.                         FileReader fis = new FileReader("c.txt");
     
159.                         FileWriter fos = new FileWriter("d.txt");
     
160.                         BufferedReader br = new BufferedReader(fis);
     
161.                         BufferedWriter bw = new BufferedWriter(fos);
     
162.                         String str;
     
163.                         while((str=br.readLine())!=null){
     
164.                                 bw.write(str);
     
165.                                 bw.newLine();
     
166.                         }
     
167.                         bw.close();
     
168.                         br.close();
     
169.                 }
     
170. }
     

复制代码

学习了，，，条理清楚，，

每种方法具体用途是什么呢  困惑啊

搞个大文件试试效果

30M文件的效果：
普通字节流  一次一个字节:      271968
普通字节流  一次一个字节数组:  342
高效字节流  一次一个字节:      1554
高效字节流  一次一个字节数组:  113
普通字符流  一次一个字符:      2699
普通字符流  一次一个字符数组:  409
高效字符流  一次一个字符数组:  435
高效字符流  一次一个字符:     1835
高效字符流  一次一行:         537
结果是：字节+数组+buffered 最高效