1. 
   
2. import java.io.*;
   
3. 
   
4. class  FileTest
   
5. {
   
6.         public static void main(String[] args) //throws IOException
   
7.         {
   
8.                 copy_2();
   
9.         }
   
10.         public static void copy_2()
    
11.         {
    
12.                 FileReader fr = null;
    
13.                 FileWriter fw = null;
    
14. 
    
15.                 try
    
16.                 {
    
17.                         fr = new FileReader("demo.txt");
    
18.                         fw = new FileWriter("democopy_2.txt");
    
19. 
    
20.                         int len = 0;
    
21.                         char[] buf = new char[1024];//定义缓冲区
    
22. 
    
23.                         while ((len = fr.read(buf))!=-1)//读入缓冲区
    
24.                         {
    
25.                                 fw.write(buf,0,len);//这里又写入缓冲区，
    
26.                                 //不怕这次写入还没刷新到硬盘，就被下一次
    
27.                                 //fr.read(buf)读入覆盖了吗？
    
28.                         }
    
29.                 }
    
30.                 catch (IOException e)
    
31.                 {
    
32.                         throw new RuntimeException("读写失败");
    
33.                 }
    
34. 
    
35.                 finally
    
36.                 {
    
37.                         if (fr!=null)
    
38.                         {
    
39.                                 try
    
40.                                 {
    
41.                                         fr.close();
    
42.                                 }
    
43.                                 catch (IOException e)
    
44.                                 {
    
45.                                 }
    
46.                                
    
47.                         }
    
48. 
    
49.                         if (fw!=null)
    
50.                         {
    
51.                                 try
    
52.                                 {
    
53.                                         fw.close();
    
54.                                 }
    
55.                                 catch (IOException e)
    
56.                                 {
    
57.                                 }
    
58.                                
    
59.                         }
    
60.                 }
    
61.         }
    
62. }
    

复制代码

while ((len = fr.read(buf))!=-1)//读入缓冲区
{
fw.write(buf,0,len);//这里又写入缓冲区，
//不怕这次写入还没刷新到硬盘，就被下一次
//fr.read(buf)读入覆盖了吗？

这是由主线程执行的读取、写入操作。中间不会有等待，都是从上向下执行，不存在并发问题。

嗯 因为定义的缓冲区数组大小是1024  如果数据没超这个限制按照代码顺序执行 最后也有
fr.close();    fw.close(); 所以数据刷新好了   如果超过这个大小  情况是和上面分析的一样主线程从新循环执行 所以并不存在并发 多线程的问题     

fw和fr开辟的不是一个内存缓冲。怎么会出现覆盖呢！
就好像在我有两个箱子，一个是frBox，一个是fwBox，从frBox中读取数据，然后放到fwBox中，不在一个Box中操作，怎么会出现覆盖情况呢。是吧