Java7新语法 -try-with-resources

翻译 2015年11月20日 15:32:41

http://docs.oracle.com/javase/7/docs/technotes/guides/language/try-with-resources.html

The try-with-resources Statement

The try-with-resources statement is a try statement that declares one or more resources. A resource is as an object that must be closed after the program is finished with it. The try-with-resources statement ensures that each resource is closed at the end of the statement. Any object that implements java.lang.AutoCloseable, which includes all objects which implement java.io.Closeable, can be used as a resource.

The following example reads the first line from a file. It uses an instance of BufferedReader to read data from the file. BufferedReader is a resource that must be closed after the program is finished with it:

使用try-with-resources, 可以自动关闭实现了AutoCloseable或者Closeable接口的资源。比如下面的函数,在try语句结束后,不论其包括的代码是正常执行完毕还是发生异常,都会自动调用BufferdReader的Close方法。

static String readFirstLineFromFile(String path) throws IOException {
  try (BufferedReader br = new BufferedReader(new FileReader(path))) {
    return br.readLine();
  }
}

In this example, the resource declared in the try-with-resources statement is a BufferedReader. The declaration statement appears within parentheses immediately after the try keyword. The class BufferedReader, in Java SE 7 and later, implements the interface java.lang.AutoCloseable. Because the BufferedReader instance is declared in a try-with-resource statement, it will be closed regardless of whether the try statement completes normally or abruptly (as a result of the method BufferedReader.readLine throwing an IOException).

Prior to Java SE 7, you can use a finally block to ensure that a resource is closed regardless of whether the try statement completes normally or abruptly. The following example uses a finally block instead of a try-with-resources statement:

在出现try-with-resources之前可以使用finally子句来确保资源被关闭, 比如下面的方法。
但是两者有一个不同在于,readFirstLineFromFileWithFinallyBlock方法中,如果finally子句中抛出异常,将会抑制try代码块中抛出的异常。
相反,readFirstLineFromFile方法中,如果try-with-resources语句中打开资源的Close方法和try代码块中都抛出了异常,Close方法抛出的异常被抑制,try代码块中的异常会被抛出。
关于这一点,可以看最后的例子。

static String readFirstLineFromFileWithFinallyBlock(String path) throws IOException {
  BufferedReader br = new BufferedReader(new FileReader(path));
  try {
    return br.readLine();
  } finally {
    if (br != null) br.close();
  }
}

However, in this example, if the methods readLine and close both throw exceptions, then the method readFirstLineFromFileWithFinallyBlock throws the exception thrown from the finally block; the exception thrown from the tryblock is suppressed. In contrast, in the example readFirstLineFromFile, if exceptions are thrown from both the try block and the try-with-resources statement, then the method readFirstLineFromFile throws the exception thrown from the try block; the exception thrown from the try-with-resources block is suppressed. In Java SE 7 and later, you can retrieve suppressed exceptions; see the section Suppressed Exceptions for more information.

You may declare one or more resources in a try-with-resources statement. The following example retrieves the names of the files packaged in the zip file zipFileName and creates a text file that contains the names of these files:

可以在一个try-with-resources语句中声明多个资源,这些资源将会以声明的顺序相反之顺序关闭, 比如下面的方法。

  public static void writeToFileZipFileContents(String zipFileName, String outputFileName)
    throws java.io.IOException {

    java.nio.charset.Charset charset = java.nio.charset.Charset.forName("US-ASCII");
    java.nio.file.Path outputFilePath = java.nio.file.Paths.get(outputFileName);

    // Open zip file and create output file with try-with-resources statement

    try (
      java.util.zip.ZipFile zf = new java.util.zip.ZipFile(zipFileName);
      java.io.BufferedWriter writer = java.nio.file.Files.newBufferedWriter(outputFilePath, charset)
    ) {

      // Enumerate each entry

      for (java.util.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());
      }
    }
  }

In this example, the try-with-resources statement contains two declarations that are separated by a semicolon: ZipFile and BufferedWriter. When the block of code that directly follows it terminates, either normally or because of an exception, the close methods of the BufferedWriter and ZipFile objects are automatically called in this order. Note that the close methods of resources are called in the opposite order of their creation.

The following example uses a try-with-resources statement to automatically close a java.sql.Statement object:

  public static void viewTable(Connection con) throws SQLException {

    String query = "select COF_NAME, SUP_ID, PRICE, SALES, TOTAL from COFFEES";

    try (Statement stmt = con.createStatement()) {

      ResultSet rs = stmt.executeQuery(query);

      while (rs.next()) {
        String coffeeName = rs.getString("COF_NAME");
        int supplierID = rs.getInt("SUP_ID");
        float price = rs.getFloat("PRICE");
        int sales = rs.getInt("SALES");
        int total = rs.getInt("TOTAL");
        System.out.println(coffeeName + ", " + supplierID + ", " + price +
                           ", " + sales + ", " + total);
      }

    } catch (SQLException e) {
      JDBCTutorialUtilities.printSQLException(e);
    }
  }

The resource java.sql.Statement used in this example is part of the JDBC 4.1 and later API.

Note: A try-with-resources statement can have catch and finally blocks just like an ordinary try statement. In a try-with-resources statement, any catch or finally block is run after the resources declared have been closed.

注意:一个try-with-resources语句也能够有catch和finally子句。catch和finally子句将会在try-with-resources子句中打开的资源被关闭之后得到调用。

Suppressed Exceptions

An exception can be thrown from the block of code associated with the try-with-resources statement. In the example writeToFileZipFileContents, an exception can be thrown from the try block, and up to two exceptions can be thrown from the try-with-resources statement when it tries to close the ZipFile and BufferedWriter objects. If an exception is thrown from the try block and one or more exceptions are thrown from the try-with-resources statement, then those exceptions thrown from the try-with-resources statement are suppressed, and the exception thrown by the block is the one that is thrown by the writeToFileZipFileContents method. You can retrieve these suppressed exceptions by calling the Throwable.getSuppressed method from the exception thrown by the try block.

注意:前面提到,如果try-with-resources语句中打开资源的Close方法和try代码块中都抛出了异常,Close 方法抛出的异常被抑制,try代码块中的异常会被抛出。
Java7之后,可以使用Throwable.getSuppressed方法获得被抑制的异常。

Classes That Implement the AutoCloseable or Closeable Interface

See the Javadoc of the AutoCloseable and Closeable interfaces for a list of classes that implement either of these interfaces. The Closeable interface extends the AutoCloseable interface. The close method of the Closeableinterface throws exceptions of type IOException while the close method of the AutoCloseable interface throws exceptions of type Exception. Consequently, subclasses of the AutoCloseable interface can override this behavior of theclose method to throw specialized exceptions, such as IOException, or no exception at all.

示例

import java.io.Closeable;
import java.io.IOException;

public class DummyClosable implements Closeable {
    private final boolean throwInClose;
    private final String name;

    public DummyClosable(boolean throwInConstruction, boolean throwInClose, String name) throws IOException {
        this.throwInClose = throwInClose;
        this.name = name;
        if (throwInConstruction) {
            throw new IOException("throwing in construction");
        }
    }

    @Override
    public void close() throws IOException {
        if (throwInClose) {
            throw new IOException("throwing in close");
        }
        System.out.println(name + " is closing...");
    }

    public static void main(String[] args) {
        try (DummyClosable d1 = new DummyClosable(false, false, "a");
                DummyClosable d2 = new DummyClosable(true, false, "b");) {
            throw new IOException("in main1");
        } catch (Exception ex) {
            ex.printStackTrace(System.out);
        }

        System.out.println("----end1----");

        try (DummyClosable d1 = new DummyClosable(false, false, "a");
                DummyClosable d2 = new DummyClosable(false, true, "b");) {
            throw new IOException("in main2");
        } catch (Exception ex) {
            ex.printStackTrace(System.out);
        }

        System.out.println("----end2----");
    }
}

运行上面的例子,结果如下:
a is closing...
java.io.IOException: throwing in construction
	at learning.io.DummyClosable.<init>(DummyClosable.java:14)
	at learning.io.DummyClosable.main(DummyClosable.java:28)
----end1----
a is closing...
java.io.IOException: in main2
	at learning.io.DummyClosable.main(DummyClosable.java:37)
	Suppressed: java.io.IOException: throwing in close
		at learning.io.DummyClosable.close(DummyClosable.java:21)
		at learning.io.DummyClosable.main(DummyClosable.java:38)
----end2----



相关文章推荐

java7新特性之Try-with-resources statement

try-with-resources 语句是一个声明了1到多个资源的try语句。资源是指这个try执行完成后必需close掉的对象,比如connection, resultset等。 try-wit...
  • ynwso
  • ynwso
  • 2012-01-30 23:43
  • 11986

Java7 新特性:try() 语句 即 try-with-resources

Try-with-resources是java7中一个新的异常处理机制,它能够很容易地关闭在try-catch语句块中使用的资源。 利用Try-Catch-Finally管理资源(旧的代码风...

Properties工具类 Helper ——Java7 try-with-resource

使用Java7 try-with-resource对Properties进行封装。

JDK 1.7 java.io 源码学习之AutoCloseable接口和try-with-resources语法

AutoCloseable try-with-resources

Java 7 新特性try-with-resources语句

1、什么是try-with-resources语句       try-with-resources 语句是一个声明一个或多个资源的 try 语句。一个资源作为一个对象,必须在程序结束之后随之关闭。 ...

Java SE7新特性之try-with-resources语句

try-with-resources语句是一个声明一个或多个资源的 try 语句。一个资源作为一个对象,必须在程序结束之后随之关闭。 try-with-resources语句确保在语句的最后每个资源都...

Java 7 try-with-resources自动关闭资源

Java 7开始,提供了一种新的语法try-with-resources用于在资源使用完毕后自动关闭资源,和python中的with语句类似。“资源”指的是实现了java.lang.AutoClose...

Java SE7新特性之try-with-resources语句

try-with-resources语句是一个声明一个或多个资源的 try 语句。一个资源作为一个对象,必须在程序结束之后随之关闭。 try-with-resources语句确保在语句的最后每个资源都...

Java SE7新特性之try-with-resources语句

http://blog.csdn.net/jackiehff/article/details/17765909     try-with-resources语句是一个声明一个或多个资源的...

Java SE 7 中带资源声明的 try 语句(try-with-resources statement)

Java SE 7 中的 try-with-resources statement 是指声明了一个或多个资源的 try 语句(声明),其中的资源一般是指在程序执行完毕後需要关闭的对象,而在 try-w...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)