1. package com.kxg.Buffer;
   
2. 
   
3. import java.io.BufferedInputStream;
   
4. import java.io.BufferedOutputStream;
   
5. import java.io.FileInputStream;
   
6. import java.io.FileOutputStream;
   
7. import java.io.IOException;
   
8. public class TestDemo {
   
9.         public static void main(String[] args) throws IOException {
   
10.                 long start1 = System.currentTimeMillis();
    
11.                 method1("a.txt", "1.txt");
    
12.                 long end1 = System.currentTimeMillis();
    
13.                 long time1 = (end1 - start1);
    
14. 
    
15.                 long start2 = System.currentTimeMillis();
    
16.                 method2("a.txt", "2.txt");
    
17.                 long end2 = System.currentTimeMillis();
    
18.                 long time2 = (end2 - start2);
    
19. 
    
20.                 long start3 = System.currentTimeMillis();
    
21.                 method3("a.txt", "3.txt");
    
22.                 long end3 = System.currentTimeMillis();
    
23.                 long time3 = (end3 - start3);
    
24. 
    
25.                 long start4 = System.currentTimeMillis();
    
26.                 method4("a.txt", "4.txt");
    
27.                 long end4 = System.currentTimeMillis();
    
28.                 long time4 = (end4 - start4);
    
29. 
    
30.                 System.out.println("普通流一次一个字节：" + time1);
    
31.                 System.out.println("普通流一次一个字节数组：" + time2);
    
32.                 System.out.println("高效流一次一个字节：" + time3);
    
33.                 System.out.println("高效流一次一个字节数组：" + time4);
    
34. 
    
35.                 // 普通流一次一个字节：28725
    
36.                 // 普通流一次一个字节数组：63
    
37.                 // 高效流一次一个字节：59
    
38.                 // 高效流一次一个字节数组：16
    
39.         }
    
40. 
    
41.         private static void method4(String srcString, String destString)
    
42.                         throws IOException {
    
43.                 // 高效字节流一次读写一个字节
    
44.                 BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
    
45.                                 srcString));
    
46.                 BufferedOutputStream bos = new BufferedOutputStream(
    
47.                                 new FileOutputStream(destString));
    
48. 
    
49.                 byte[] by = new byte[1024];
    
50.                 int len = 0;
    
51.                 while ((len = bis.read(by)) != -1) {
    
52.                         bos.write(by, 0, len);
    
53.                 }
    
54.         }
    
55. 
    
56.         private static void method3(String srcString, String destString)
    
57.                         throws IOException {
    
58.                 // 高效字节流一次读写一个字节
    
59.                 BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
    
60.                                 srcString));
    
61.                 BufferedOutputStream bos = new BufferedOutputStream(
    
62.                                 new FileOutputStream(destString));
    
63. 
    
64.                 int len = 0;
    
65.                 while ((len = bis.read()) != -1) {
    
66.                         bos.write(len);
    
67.                 }
    
68.         }
    
69. 
    
70.         private static void method2(String srcString, String destString)
    
71.                         throws IOException {
    
72.                 // 一次读写一个字节数组
    
73.                 FileInputStream fis = new FileInputStream(srcString);
    
74.                 FileOutputStream fos = new FileOutputStream(destString);
    
75. 
    
76.                 byte[] by = new byte[1024];
    
77.                 int len = 0;
    
78.                 while ((len = fis.read(by)) != -1) {
    
79.                         fos.write(by, 0, len);
    
80.                 }
    
81.                 fis.close();
    
82.                 fos.close();
    
83.         }
    
84. 
    
85.         private static void method1(String srcString, String destString)
    
86.                         throws IOException {
    
87.                 // 一次读写一个字节
    
88.                 FileInputStream fis = new FileInputStream(srcString);
    
89.                 FileOutputStream fos = new FileOutputStream(destString);
    
90. 
    
91.                 int len = 0;
    
92.                 while ((len = fis.read()) != -1) {
    
93.                         fos.write(len);
    
94.                 }
    
95.                 fis.close();
    
96.                 fos.close();
    
97.         }
    
98. }

复制代码

good好帖子，多谢了