试用期java_Java试用资源

试用期java

Today we will look into Java Try with Resources. One of the Java 7 feature is try-with-resources statement for automatic resource management.

今天，我们将研究Java试用资源。 Java 7的功能之一是用于自动资源管理的try-with-resources语句。

尝试使用资源 (Try with Resources)

A resource is an object that must be closed once your program is done using it. For example, a File resource or JDBC resource for a database connection or a Socket connection resource. Before Java 7, there was no auto resource management and we should explicitly close the resource once our work is done with it. Usually, it was done in the finally block of a try-catch statement. This approach used to cause memory leaks and performance hit when we forgot to close the resource.

资源是一个对象，一旦您的程序完成使用它就必须关闭它。例如，用于数据库连接或套接字连接资源的文件资源或JDBC资源。在Java 7之前，没有自动资源管理，一旦完成工作，就应该显式关闭资源。通常，它是在try-catch语句的finally块中完成的。当我们忘记关闭资源时，这种方法曾经导致内存泄漏和性能下降。

Let’s see a pseudo code snippet to understand this java try with resources feature.

让我们看一个伪代码片段，以理解此Java资源尝试功能。

Before Java 7:

在Java 7之前 ：

try{//open resources like File, Database connection, Sockets etc
} catch (FileNotFoundException e) {// Exception handling like FileNotFoundException, IOException etc
}finally{// close resources
}

Java 7 try with resources implementation:

Java 7尝试使用资源实现 ：

try(// open resources here){// use resources
} catch (FileNotFoundException e) {// exception handling
}
// resources are closed as soon as try-catch block is executed.

Let’s write a simple program to read a file and print the first line using Java 6 or older versions and Java 7 try-with-resources implementation.

让我们编写一个简单的程序来读取文件并使用Java 6或更早版本和Java 7 try-with-resources实现打印第一行。

Java 6资源管理示例 (Java 6 Resource Management Example)

package com.journaldev.util;import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;public class Java6ResourceManagement {public static void main(String[] args) {BufferedReader br = null;try {br = new BufferedReader(new FileReader("C:\\journaldev.txt"));System.out.println(br.readLine());} catch (IOException e) {e.printStackTrace();} finally {try {if (br != null)br.close();} catch (IOException ex) {ex.printStackTrace();}}}
}

Java 7试用资源示例 (Java 7 Try With Resources Example)

package com.journaldev.util;import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;public class Java7ResourceManagement {public static void main(String[] args) {try (BufferedReader br = new BufferedReader(new FileReader("C:\\journaldev.txt"))) {System.out.println(br.readLine());} catch (IOException e) {e.printStackTrace();}}
}

Java试用资源的好处 (Java try with resources benefits)

Some of the benefits of using try with resources in java are;

在Java中对资源使用try的一些好处是；

More readable code and easy to write.更具可读性的代码，易于编写。
Automatic resource management.自动资源管理。
Number of lines of code is reduced.代码行数减少。
No need of finally block just to close the resources.无需最终阻塞即可关闭资源。

We can open multiple resources in try-with-resources statement separated by a semicolon. For example, we can write following code:

try (BufferedReader br = new BufferedReader(new FileReader("C:\\journaldev.txt"));java.io.BufferedWriter writer = java.nio.file.Files.newBufferedWriter(FileSystems.getDefault().getPath("C:\\journaldev.txt"), Charset.defaultCharset())) {System.out.println(br.readLine());} catch (IOException e) {e.printStackTrace();}

我们可以在以分号分隔的try-with-resources语句中打开多个资源。例如，我们可以编写以下代码：

When multiple resources are opened in try-with-resources, it closes them in the reverse order to avoid any dependency issue. You can extend my resource program to prove that.当在try-with-resources中打开多个资源时，它将以相反的顺序关闭它们，以避免任何依赖关系问题。您可以扩展我的资源计划以证明这一点。

Java 7 has introduced a new interface java.lang.AutoCloseable. To use any resource in try-with-resources, it must implement AutoCloseable interface else java compiler will throw compilation error.

Java 7引入了新接口java.lang.AutoCloseable 。要在try-with-resources中使用任何资源，它必须实现AutoCloseable接口，否则Java编译器将抛出编译错误。

Lets confirm this with an example:

让我们用一个例子来确认这一点：

package com.journaldev.util;import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.file.FileSystems;public class Java7ResourceManagement {public static void main(String[] args) {try (MyResource mr = new MyResource()) {System.out.println("MyResource created in try-with-resources");} catch (Exception e) {e.printStackTrace();}System.out.println("Out of try-catch block.");}static class MyResource implements AutoCloseable{@Overridepublic void close() throws Exception {System.out.println("Closing MyResource");}}
}

The output of the above program is:

上面程序的输出是：

MyResource created in try-with-resources
Closing MyResource
Out of try-catch block.

From the output, it’s clear that as soon as the try-catch block is finished, the resource close method is called.

从输出中很明显，一旦try-catch块完成，就将调用资源关闭方法。

尝试使用资源异常 (Try with Resources Exceptions)

There is one difference to note between try-catch-finally and try-with-resources in case of exceptions.

在出现异常的情况下，try-catch-finally和try-with-resources之间有一个区别。

If an exception is thrown in both try block and finally block, the method returns the exception thrown in finally block.

如果在try块和finally块中都抛出了异常，则该方法返回在finally块中抛出的异常。

For try-with-resources, if an exception is thrown in a try block and in a try-with-resources statement, then the method returns the exception thrown in the try block.

对于try-with-resources，如果在try块和try-with-resources语句中引发了异常，则该方法将返回在try块中引发的异常。

To better clarify this difference, we will see sample code.

为了更好地阐明这种差异，我们将看到示例代码。

package com.journaldev.util;public class Java7ResourceManagement {public static void main(String[] args) throws Exception {try {tryWithResourceException();} catch (Exception e) {System.out.println(e.getMessage());}try {normalTryException();} catch (Exception e) {System.out.println(e.getMessage());}}private static void normalTryException() throws Exception {MyResource mr = null;try {mr = new MyResource();System.out.println("MyResource created in the try block");if (true)throw new Exception("Exception in try");} finally {if (mr != null)mr.close();}}private static void tryWithResourceException() throws Exception {try (MyResource mr = new MyResource()) {System.out.println("MyResource created in try-with-resources");if (true)throw new Exception("Exception in try");}}static class MyResource implements AutoCloseable {@Overridepublic void close() throws Exception {System.out.println("Closing MyResource");throw new Exception("Exception in Closing");}}
}

The output of the above program is:

上面程序的输出是：

MyResource created in try-with-resources
Closing MyResource
Exception in try
MyResource created in the try block
Closing MyResource
Exception in Closing

The output of the program proves the difference given above. That’s all for the Java 7 try-with-resources.

程序的输出证明了上面给出的差异。这就是Java 7 try-with-resources的全部内容。

翻译自: https://www.journaldev.com/592/java-try-with-resources

试用期java