1. import java.io.*;
   
2. class  CopyTest
   
3. {
   
4.         public static void main(String[] args)
   
5.         {
   
6.                  copy_2();
   
7.         }
   
8.         //方式一：读取一个复制一个
   
9.         public static void copy_1()
   
10.         {
    
11.                 FileWriter fw = null;
    
12.                 FileReader fr = null;
    
13.                 try
    
14.                 {
    
15.                         fw = new FileWriter("hehe_copy.txt");//创建一个目的文件
    
16.                         fr = new FileReader("Test.txt");//读取出需要被复制的文件
    
17. 
    
18.                         int ch = 0;
    
19.                         while ((ch = fr.read())!=-1)
    
20.                         {
    
21.                                  fw.write(ch);
    
22.                         }
    
23.                 }
    
24.                 catch (IOException e)
    
25.                 {
    
26.                         System.out.println(e.toString());
    
27.                 }
    
28.                 finally
    
29.                 {
    
30.                         if (fr!=null)
    
31.                         {
    
32.                                 try
    
33.                                 {
    
34.                                         fr.close();
    
35.                                 }
    
36.                                 catch (IOException e)
    
37.                                 {
    
38.                                         System.out.println(e.toString());
    
39.                                 }
    
40.                                
    
41.                         }
    
42.                         if (fw!=null)
    
43.                         {
    
44.                                 try
    
45.                                 {
    
46.                                         fw.close();
    
47.                                 }
    
48.                                 catch (IOException e)
    
49.                                 {
    
50.                                         System.out.println(e.toString());
    
51.                                 }
    
52.                                
    
53.                         }
    
54.                 }
    
55.         }
    
56.         //方式二：先复制到数组，然后一次性把数组中的元素取出！再接着往数组中存储，取出！
    
57.         public static void copy_2()
    
58.         {
    
59.                         FileWriter fw = null;
    
60.                         FileReader fr = null;
    
61.                         try
    
62.                         {
    
63.                                 fw = new FileWriter("hehe_copy.txt");//创建一个目的文件
    
64.                                 fr = new FileReader("Test.txt");//读取出需要被复制的文件
    
65. 
    
66.                                 char [] buf = new char[1024];
    
67.                                 int num = 0;
    
68.                                 while ((num = fr.read(buf))!=-1)
    
69.                                 {
    
70.                                         fw.write(buf);
    
71.                                 }
    
72.                         }
    
73.                         catch (IOException e)
    
74.                         {
    
75.                                 System.out.println(e.toString());
    
76.                         }
    
77.                         finally
    
78.                         {
    
79.                                 if (fr!=null)
    
80.                                 {
    
81.                                         try
    
82.                                         {
    
83.                                                 fr.close();
    
84.                                         }
    
85.                                         catch (IOException e)
    
86.                                         {
    
87.                                                 System.out.println(e.toString());
    
88.                                         }
    
89.                                        
    
90.                                 }
    
91.                                 if (fw!=null)
    
92.                                 {
    
93.                                         try
    
94.                                         {
    
95.                                                 fw.close();
    
96.                                         }
    
97.                                         catch (IOException e)
    
98.                                         {
    
99.                                                 System.out.println(e.toString());
    
100.                                         }
     
101.                                        
     
102.                                 }
     
103.                         }
     
104.                 }
     
105.         }
     
106. 
     

复制代码

谢谢分享哦

学习下谢谢分享

谢谢分享~~

谢谢  楼主 分享..

哈哈，毕老师的视频，昨天刚看到这个地方。。。

谢谢分享！

第二种方式其实就是定义自己的缓冲区，在对字节流操作时这种手段可以有效提高代码执行效率，而缓冲流Buffered...是可以操作字符流的。这儿为了提高效率楼主可以使用缓冲流。

谢谢楼主,复习了

还是用缓冲快。。

很高端啊，还没有看到这个地方

谢谢分享