写了一个用缓冲区，将一个文本复制到另一个文本的小代码

1. import java.io.FileReader;
   
2. import java.io.FileWriter;
   
3. import java.io.BufferedReader;
   
4. import java.io.BufferedWriter;
   
5. import java.io.IOException;
   
6. 
   
7. class BufferedDemo
   
8. {
   
9.         public static void main(String[] args)
   
10.         {
    
11.                 FileReader fr = null;
    
12.                 FileWriter fw = null;
    
13.                 BufferedReader br = null;
    
14.                 BufferedWriter bw = null;
    
15. 
    
16.                 try
    
17.                 {
    
18.                         fr = new FileReader("RuntimeDemo.java");
    
19.                         fw = new FileWriter("F:/RuntimeDemo.txt");
    
20.                         br = new BufferedReader(fr);
    
21.                         bw = new BufferedWriter(fw);
    
22. 
    
23.                         for(String line;(line=br.readLine())!=null;)
    
24.                         {
    
25.                                 bw.write(line);
    
26.                                 bw.newLine();
    
27.                                 bw.flush();
    
28.                         }
    
29. 
    
30.                 }
    
31.                 catch (IOException ioe)
    
32.                 {
    
33.                         throw new RuntimeException("文件读写异常");
    
34.                 }
    
35.                 finally
    
36.                 {
    
37.                         if (fr!=null)
    
38.                         {
    
39.                                 try
    
40.                                 {
    
41.                                         fr.close();
    
42.                                 }
    
43.                                 catch (IOException ioe)
    
44.                                 {
    
45.                                         throw new RuntimeException("读文件关闭异常");
    
46.                                 }
    
47.                         }
    
48.                         if (bw!=null)
    
49.                         {
    
50.                                 try
    
51.                                 {
    
52.                                         br.close();
    
53.                                 }
    
54.                                 catch (IOException ioe)
    
55.                                 {
    
56.                                         throw new RuntimeException("写文件关闭异常");
    
57.                                 }
    
58.                         }
    
59.                 }
    
60.         }
    
61. }
    
62. 
    

复制代码

我想知道，这个流关闭的时候到底怎么关呢？因为建立了四个流对象。
所以，有没这种可能：fr对象确实建立了，而br建立失败呢？
这样的话，finally中用下边代码关闭流是不是会更合适（因为我理解的是：br.close()调用的就是fr.close(),所以是不是，用fr关了，br就不用关了？）？
finally
{
                           if (fr!=null)
                           {
                                try
                                {
                                        fr.close();
                                }
                                catch (IOException ioe)
                                {
                                        throw new RuntimeException("读文件关闭异常");
                                }
                        }
}

======================================================
我想知道最专业的处理方式在建立对象上改进还是在关闭流上改进？是如何改的呢？

不要关fr和fw，关了br和bw就好了，它们自己并未调用底层资源，调用关闭方法时实际上就是在调用所接收的流对象，也就是fr和fw

水竹 发表于 2014-10-10 11:53
不要关fr和fw，关了br和bw就好了，它们自己并未调用底层资源，调用关闭方法时实际上就是在调用所接收的流对 ...

那万一 br和bw没创建成功，而fr和fw却创建成功了怎么办？

路过。。。

小黑子 发表于 2014-10-10 17:08
那万一 br和bw没创建成功，而fr和fw却创建成功了怎么办？

不会出现这种情况的，因为BufferedReader和BufferedWriter本身并不涉及IO操作，所以你说的问题并不存在。

水竹 发表于 2014-10-10 17:38
不会出现这种情况的，因为BufferedReader和BufferedWriter本身并不涉及IO操作，所以你说的问题并不存在。 ...

Soga,是这个样子啊，谢谢哈。

小黑子 发表于 2014-10-10 17:41
Soga,是这个样子啊，谢谢哈。

不谢