第一种:采用FileInputStream字节流的方式,
即: FileInputStream fis=new FileInputStream(“……”);
Fis.read();
这种方式每次只获取一个字节的数据，而要复制的数据变大时，就要增加大量的循环次数，才可以把所有数据复制完，——速度是相当的慢，平时开发今本不用这种复制方式。
第二种：采用FileInputStream + byte[] 的方式，
及FileInputStream fis=new FileInputStream(“……”);
Byte[] b=new byte[1024];//一般情况下都是使用1024长度的                                                                        //数组

Fis.read(b);
这种方式，是将读取的数据先存储在字节数据中，然后再对数据进行输入，输出操作，大大降低了循环次数，并且往数组中存储数据是相对比较快的操作。
第三种
采用字符流缓冲区对象复制文件
即：BufferedInputStream+FileInputStream读取数据源
BufferedInputStream bis=new BufferedInputStream(new FileInputStream(“……”))；
Bis.read();
采用字符流缓冲区对象，是专门解决字节流读取写入数据慢的问题。
第四种：
及在第三种的方式上采用读取数据存入 byte[] 中。

写数据 和读数据一致。。。


下面是四种方法：及每种方法的复制速度比较。

1. /*
   
2. * 进行文件复制方法   及效率对比
   
3. * 四种方式
   
4. *   1. 字节流读写单个字节  135095
   
5. *   2. 字节流读写字节数组  208   推荐
   
6. *   3. 缓冲区读写单个字节  1187
   
7. *   4. 缓冲区读写字节数组  90    强烈推荐
   
8. *   我们复制一个25M大小的视屏文件1.avi
   
9. *   数据源: c:\\1.avi
   
10. *   数据目的: d:\\1.avi
    
11. *   
    
12. *   自己的复制功能,比固体要快,比Windows也要快
    
13. *   为什么:
    
14. *     流底层也是找Windows读写
    
15. *     固态中,复制文件,依赖Windows
    
16. *     复制,实现很多功能:
    
17. *        目的,够不够装文件
    
18. *        判断用户有没有复制权限,粘贴权限
    
19. *   
    
20. */
    
21. import java.io.*;
    
22. public class CopyFile_Test {
    
23.         public static void main(String[] args) {
    
24.                 // 测试效率,采用毫秒值计算
    
25.                 long start = System.currentTimeMillis();
    
26.                 copy_4();
    
27.                 long end = System.currentTimeMillis();
    
28.                 System.out.println(end - start);
    
29.         }
    
30.         /*
    
31.          * 4. 缓冲区读写字节数组
    
32.          */
    
33.         public static void copy_4(){
    
34.                 // 创建2个缓冲区流的变量,=null
    
35.                 BufferedInputStream bis = null;
    
36.                 BufferedOutputStream bos = null;
    
37.                 try {
    
38.                         // 创建字节流缓冲区对象,传递字节流
    
39.                         bis = new BufferedInputStream(
    
40.                                         new FileInputStream("c:\\m.exe"));
    
41. 
    
42.                         // 创建字节输出流缓冲区对象,传递字节输出流
    
43.                         bos = new BufferedOutputStream(
    
44.                                         new FileOutputStream("d:\\m.exe"));
    
45. 
    
46.                         // 读写字节数组
    
47. /*
    
48. *当数组长度,在一定范围内长度更大的时候,复制速度会更快,
    
49. *但如果过长,系统在为bytes分配数组的时间就会很长,反而降低了复         *制速度.所以不能使用太长的数组.
    
50. */
    
51.                         byte[] bytes = new byte[1024];
    
52. 
    
53.                         int len = 0;
    
54.                         while ((len = bis.read(bytes)) != -1) {
    
55.                                 bos.write(bytes,0,len);
    
56.                         }
    
57.                 } catch (IOException ex) {
    
58.                         throw new RuntimeException("文件复制失败");
    
59.                 } finally {
    
60.                         MyCloseStream.close(bis, bos);
    
61.                 }       
    
62.         }
    
63. 
    
64.         /*
    
65.          * 3. 缓冲区读写单个字节
    
66.          */
    
67.         public static void copy_3() {
    
68.                 // 创建2个缓冲区流的变量,=null
    
69.                 BufferedInputStream bis = null;
    
70.                 BufferedOutputStream bos = null;
    
71.                 try {
    
72.                         // 创建字节流缓冲区对象,传递字节流
    
73.                         bis = new BufferedInputStream(
    
74.                                         new FileInputStream("c:\\1.avi"));
    
75. 
    
76.                         // 创建字节输出流缓冲区对象,传递字节输出流
    
77.                         bos = new BufferedOutputStream(
    
78.                                         new FileOutputStream("d:\\1.avi"));
    
79. 
    
80.                         // 读写单个字节
    
81.                         int len = 0;
    
82.                         while ((len = bis.read()) != -1) {
    
83.                                 bos.write(len);
    
84.                         }
    
85.                 } catch (IOException ex) {
    
86.                         throw new RuntimeException("文件复制失败");
    
87.                 } finally {
    
88.                         MyCloseStream.close(bis, bos);
    
89.                 }
    
90.         }
    
91. 
    
92.         /*
    
93.          * 2. 字节流读写字节数组
    
94.          */
    
95.         public static void copy_2() {
    
96.                 FileInputStream fis = null;
    
97.                 FileOutputStream fos = null;
    
98.                 try {
    
99.                         fis = new FileInputStream("c:\\1.avi");
    
100.                         fos = new FileOutputStream("d:\\1.avi");
     
101.                         // 定义字节数组,长度1024整数倍
     
102.                         byte[] bytes = new byte[1024];
     
103.                         int len = 0;
     
104.                         while ((len = fis.read(bytes)) != -1) {
     
105.                                 // fos流写字节数组
     
106.                                 fos.write(bytes, 0, len);
     
107.                         }
     
108.                 } catch (IOException ex) {
     
109.                         ex.printStackTrace();
     
110.                         throw new RuntimeException("复制失败");
     
111.                 } finally {
     
112.                         // 调用工具类close方法
     
113.                         MyCloseStream.close(fis, fos);
     
114.                 }
     
115.         }
     
116. 
     
117.         /*
     
118.          * 1. 字节流读写单个字节
     
119.          */
     
120.         public static void copy_1() {
     
121.                 // 声明2个流对象,=null
     
122.                 FileInputStream fis = null;
     
123.                 FileOutputStream fos = null;
     
124.                 try {
     
125.                         // 创建2个流对象,new
     
126.                         fis = new FileInputStream("c:\\1.avi");
     
127.                         fos = new FileOutputStream("d:\\1.avi");
     
128.                         // fis读取1个字节,fos写1个字节
     
129.                         int len = 0;
     
130.                         while ((len = fis.read()) != -1) {
     
131.                                 fos.write(len);
     
132.                         }
     
133.                 } catch (IOException ex) {
     
134.                         ex.printStackTrace();
     
135.                         throw new RuntimeException("复制失败");
     
136.                 } finally {
     
137.                         MyCloseStream.close(fis, fos);
     
138.                 }
     
139.         }
     
140. }
     
141. 
     
142. 
     
143. 
     
144. MyCloseStream.java
     
145. 
     
146. /*  关闭方法close的细节
     
147. *  单独的close方法,定义一套自己的try catch处理
     
148. *  保证所有的close都会执行到
     
149. */
     
150. import java.io.*;
     
151. public class CopyFile {
     
152.         public static void main(String[] args) {
     
153.                 //声明2个流对象,=null
     
154.                 FileInputStream fis = null;
     
155.                 FileOutputStream fos = null;
     
156.                 try{
     
157.                         //创建2个流对象,new
     
158.                         fis = new FileInputStream("c:\\t.jpg");
     
159.                         fos = new FileOutputStream("d:\\t.jpg");
     
160.                         //fis读取1个字节,fos写1个字节
     
161.                         int len = 0 ;
     
162.                         while((len = fis.read())!=-1){
     
163.                                 fos.write(len);
     
164.                         }
     
165.                 }catch(IOException ex){
     
166.                         ex.printStackTrace();
     
167.                         throw new RuntimeException("复制失败");
     
168.                 }finally{
     
169.                         try{
     
170.                                 if(fos!=null)
     
171.                                         fos.close();
     
172.                         }catch(IOException ex){
     
173.                                 throw new RuntimeException("释放资源失败");
     
174.                         }finally{
     
175.                                 try{
     
176.                                         if(fis!=null)
     
177.                                                 fis.close();
     
178.                                 }catch(IOException ex){
     
179.                                         throw new RuntimeException("释放资源失败");
     
180.                                 }
     
181.                         }
     
182.                 }
     
183.         }
     
184. }
     

复制代码

希望对要学IO的有一丁点帮助。

总结的听到位，谢谢分享

我们要自己写try...catch...呢？