的Java IO醜陋的try-finally塊

Question

是否有治療close()例外，關閉兩個流，那麼的不那麼醜陋的方式：

InputStream in = new FileInputStream(inputFileName); 
    OutputStream out = new FileOutputStream(outputFileName); 

    try { 
     copy(in, out); 
    } finally { 
     try { 
      in.close(); 
     } catch (Exception e) { 
      try { 
       // event if in.close fails, need to close the out 
       out.close(); 
      } catch (Exception e2) {} 
       throw e; // and throw the 'in' exception 
      } 
     } 
     out.close(); 
    } 

更新：所有上面的代碼是一個嘗試，漁獲物中，由於爲警告。

FINALLY（後回答）：

，並可以使用Execute Around idiom（感謝湯姆Hawtin）做一個很好的實用方法。

Answer 1

這是正確的IDOM（它工作正常）：

InputStream in = null; 
    OutputStream out = null; 
    try { 
     in = new FileInputStream(inputFileName); 
     out = new FileOutputStream(outputFileName); 
     copy(in, out); 
    finally { 
     close(in); 
     close(out); 
    } 

    public static void close(Closeable c) { 
    if (c == null) return; 
    try { 
     c.close(); 
    } catch (IOException e) { 
     //log the exception 
    } 
    } 

能正常工作的原因是，拋出異常你得終於將你的最終代碼完成後拋出之前，前提是你的最後代碼本身不會拋出異常或以其他方式異常終止。

編輯：從Java 7（和Android SDK 19 - KitKat）開始，現在有一個Try with resources語法來使這個更清晰。如何處理這個問題在this question。

Answer 2

我有時使用的一個技巧是定義一個名爲closeQuietly(Closeable)的方法，該方法測試它的參數是否爲null然後關閉它，忽略任何異常。但是你需要小心地關閉OutputStreams和Writers，因爲它們實際上可能會拋出異常，很重要;例如如果最終刷新失敗。

隨着Java 7的發展，情況可能會有所改善。報告指出，它將有一個新的構造，它提供了一種更簡潔的方式來處理託管資源;例如需要在完成時關閉的流。

最後，你應該知道你的例子有一個錯誤。如果方法調用打開第二個流，則第一個流將不會關閉。第二次打開需要在try區塊內完成。

Answer 3

你可以實現一個實用方法：

public final class IOUtil { 
    private IOUtil() {} 

    public static void closeQuietly(Closeable... closeables) { 
    for (Closeable c : closeables) { 
     if (c != null) try { 
      c.close(); 
     } catch(Exception ex) {} 
    } 
    } 
} 

那麼你的代碼將被簡化爲：

try { 
    copy(in, out); 
} finally { 
    IOUtil.closeQuietly(in, out); 
} 

附加

我想象還會有這樣的方法在第三方開源庫中。但是，我的首選是避免不必要的庫依賴項，除非我使用其大部分功能。因此我傾向於自己實現這樣的簡單實用方法。

Answer 4

在大多數情況下，「在」 close（）方法的例外是不相關的，因此：

try { 
     copy(in, out); 
    } finally { 
    try { in.close() } catch (Exception e) { /* perhaps log it */ } 
    try { out.close() } catch (Exception e) {/* perhaps log it */ } 
    } 

它通常是不好的做法，吞下例外，但在這種情況下，我認爲這是好的。

Answer 5

try { 
    final InputStream in = new FileInputStream(inputFileName); 
    try { 
     final OutputStream out = new FileOutputStream(outputFileName);  
     try { 
      copy(in, out); 
      out.flush(); // Doesn't actually do anything in this specific case. 
     } finally { 
      out.close(); 
     } 
    } finally { 
     in.close(); 
    } 
} catch (IOException exc) { 
    throw new SomeRelevantException(exc); 
} 

記住，打開一個流可能會拋出一個異常，那麼你就需要氣流出口之間的try（請不要做一些黑客涉及null秒。任何事情都有可能引發Error（這不是一個實例的Exception）。

事實證明，catch和finally應該很少共享相同的try。

由於Java SE 7，你可以寫使用try-與資源以避免這麼多的缺口，這或多或少做同樣的事情，雖然有抑制異常隱藏。

try (
    final InputStream in = new FileInputStream(inputFileName); 
    final OutputStream out = new FileOutputStream(outputFileName);  
) { 
    copy(in, out); 
    out.flush(); // Doesn't actually do anything in this specific case. 
} catch (IOException exc) { 
    throw new SomeRelevantException(exc); 
} 

您可能想要使用Execute Around idiom。

我相信標準的好方法是使用NIO的transferTo/transferFrom。

Answer 6

你有，在普通的io，在IOUtils，一些close平靜方法。

Answer 7

Guava有非常好的IO API，消除這種需要。例如，你的例子是：

Files.copy(new File(inputFileName), new File(outputFileName)); 

更一般地，它使用的InputSupplier S和OutputSupplier S上的概念，讓InputStream S和OutputStream s到被它的實用方法中創建，允許它在他們完全控制所以它可以正確處理關閉。

此外，它有Closeables.closeQuietly(Closeable)這基本上是大多數答案建議的方法的類型。

其中的IO內容仍處於測試階段，可能會發生變化，但值得檢查甚至使用，具體取決於您的工作內容。

Answer 8

我堅信在Java 7.0中，您不需要再自己關閉流。 Language Features in Java 7

try (BufferedReader br = new BufferedReader(new FileReader(path)) { 
    return br.readLine(); 
} 

Answer 9

在C＃中，有using建設會自動關閉關閉的對象，當我們離開的範圍：

using(Stream s = new Stream(filename)) { 
    s.read(); 
} 

我認爲這是對Java的嘗試-finally塊的簡寫形式。 Java 6引入了Closable接口。所以，using幾乎就在那裏。當最後一步在Java 7中完成時，確實會非常棒。

Answer 10

使用

IOUtils.closeNoThrow(myInputStream);

古樸典雅。

Answer 11

由於的Java 7有寫嘗試，終於在問候塊來Closeable資源方面更好的方式。現在

可以在try關鍵字後括號內創建你的資源，像這樣：

try (initialize resources here) { 
    ... 
} 

與上面的代碼塊結束後，他們將被關閉自動。 finally部分不需要。

一個例子：

try (
    ZipFile zf = new ZipFile(zipFileName); 
    BufferedWriter writer = Files.newBufferedWriter(outputFilePath, charset); 
) { 
    // Enumerate each entry 
    for (Enumeration entries = zf.entries(); entries.hasMoreElements();) { 
     // Get the entry name and write it to the output file 
     String newLine = System.getProperty("line.separator"); 
     String zipEntryName = ((java.util.zip.ZipEntry)entries.nextElement()).getName() + newLine; 
     writer.write(zipEntryName, 0, zipEntryName.length()); 
    } 
} 

而且for循環完成後，資源將被關閉！

Answer 12

這裏是我的回答希望更好

https://stackoverflow.com/a/35623998/2585433

try { 
    fos = new FileOutputStream(new File("...")); 
    bos = new BufferedOutputStream(fos); 
    oos = new ObjectOutputStream(bos); 
} 
catch (Exception e) { 
} 
finally { 
    Stream.close(oos,bos,fos); 
} 


class Stream { 

public static void close(AutoCloseable... array) { 
    for (AutoCloseable c : array) { 
     try {c.close();} 
     catch (IOException e) {} 
     catch (Exception e) {} 
    } 
    } 
}