How to use try-finally block in Java?
try-finally ensures that the code is always executed and is often used for resource cleanup; no matter whether an exception or return occurs, the finally block will run, except when the JVM exits or the thread is interrupted; after Java 7, it is recommended to use try-with-resources to automatically manage resources that implement AutoCloseable.
The try-finally block in Java is used to ensure that a piece of code always runs, regardless of whether an exception occurs in the try block. This is especially useful for cleaning up resources like closing files, database connections, or network streams.
Basic Syntax of try-finally
A try-finally block consists of a try block followed by a finally block. There's no catch block involved in this structure.
try {
// Code that might throw an exception
} finally {
// Code that always executes
}
The finally block will run whether an exception is thrown or not. Even if there's a return statement inside the try block, the finally block will execute before the method returns.
When to Use try-finally
You should use try-finally when you need to guarantee cleanup actions happen. Common scenarios include:
- Closing file readers/writers
- Releasing locks in multithreading
- Shutting down executors or connection pools
FileReader reader = null;
try {
reader = new FileReader("data.txt");
int character;
while ((character = reader.read()) != -1) {
System.out.print((char) character);
}
} finally {
if (reader != null) {
reader.close(); // Always close the resource
}
}
Important Notes About finally
The behavior of finally can be tricky in some cases:
- If the JVM exits (eg, via System.exit() ) during the try block, the finally block won't execute.
- If the thread executing the try block is interrupted or killed, finally may not run.
- If there's a return statement in the try block, the finally block runs before the actual return.
- If both try and finally have return statements, the one in finally takes precedence.
public static String example() {
try {
return "from try";
} finally {
System.out.println("finally always runs");
}
}
This prints "finally always runs" and returns "from try". The message appears before the return completes.
Modern Alternative: Try-with-Resources
Since Java 7, try-with-resources is preferred when working with AutoCloseable resources. It automatically closes resources and makes code cleaner.
try (FileReader reader = new FileReader("data.txt")) {
int character;
while ((character = reader.read()) != -1) {
System.out.print((char) character);
}
} // reader is closed automatically here
This approach reduces boilerplate and lowers the risk of resource leaks.
Basically, use try-finally when you need guaranteed execution of cleanup code and can't use try-with-resources. It's reliable for managing resources manually, but prefer try-with-resources for anything that implements AutoCloseable.
The above is the detailed content of How to use try-finally block in Java?. For more information, please follow other related articles on the PHP Chinese website!
Hot AI Tools
Undress AI Tool
Undress images for free
AI Clothes Remover
Online AI tool for removing clothes from photos.
Undresser.AI Undress
AI-powered app for creating realistic nude photos
ArtGPT
AI image generator for creative art from text prompts.
Stock Market GPT
AI powered investment research for smarter decisions
Hot Article
Popular tool
Notepad++7.3.1
Easy-to-use and free code editor
SublimeText3 Chinese version
Chinese version, very easy to use
Zend Studio 13.0.1
Powerful PHP integrated development environment
Dreamweaver CS6
Visual web development tools
SublimeText3 Mac version
God-level code editing software (SublimeText3)
Hot Topics
20519
7
13632
4
How to configure Spark distributed computing environment in Java_Java big data processing
Mar 09, 2026 pm 08:45 PM
Spark cannot run in local mode, ClassNotFoundException: org.apache.spark.sql.SparkSession. This is the most common first step of getting stuck: even the dependencies are not correct. Only spark-core_2.12 is written in Maven, but spark-sql_2.12 is not added. SparkSession crashes as soon as it is built. The Scala version must strictly match the official Spark compiled version - Spark3.4.x uses Scala2.12 by default. If you use spark-sqljar of 2.13, the class loader cannot directly find the main class. Practical advice: Go to mvnre
How to safely map user-entered weekday string to integer value and implement date offset operation in Java
Mar 09, 2026 pm 09:43 PM
This article introduces a concise and maintainable way to map the weekday string (such as "Monday") to the corresponding serial number (1-7), and use the modulo operation to realize the forward and backward offset of any number of days (such as Monday plus 4 days to get Friday), avoiding lengthy if chains and hard-coded logic.
How to generate a list of duplicate elements using Java's Collections.nCopies_Initialization tips
Mar 06, 2026 am 06:24 AM
Collections.nCopies returns an immutable view. Calling add/remove will throw UnsupportedOperationException; it needs to be wrapped with newArrayList() to modify it, and it is disabled for mutable objects.
How to use Homebrew to install Java on Mac_A must-have Java tool chain for developers
Mar 09, 2026 pm 09:48 PM
Homebrew installs the latest stable version of openjdk (such as JDK22) by default, not the LTS version; you need to explicitly execute brewinstallopenjdk@17 or brewinstallopenjdk@21 to install the LTS version, and manually configure PATH and JAVA_HOME to be correctly recognized by the system and IDE.
What is exception masking (Suppressed Exceptions) in Java_Multiple resource shutdown exception handling
Mar 10, 2026 pm 06:57 PM
What is SuppressedException: It is not "swallowed", but actively archived by the JVM. SuppressedException is not an exception loss, but the JVM quietly attaches the secondary exception to the main exception under the premise that "only one exception must be thrown" for you to verify afterwards. It is automatically triggered by the JVM in only two scenarios: one is that the resource closure in try-with-resources fails, and the other is that you manually call addSuppressed() in finally. The key difference is: the former is fully automatic and safe; the latter requires you to keep it to yourself, and it can be written as shadowing if you are not careful. try-
How to correctly implement runtime file writing in Java applications (avoiding JAR internal write failures)
Mar 09, 2026 pm 07:57 PM
After a Java application is packaged as a JAR, data cannot be written directly to the resources in the JAR package (such as test.txt) because the JAR is essentially a read-only ZIP archive; the correct approach is to write variable data to an external path (such as a user directory, a temporary directory, or a configuration-specified path).
What is the underlying principle of array expansion in Java_Java memory dynamic adjustment analysis
Mar 09, 2026 pm 09:45 PM
ArrayList.add() triggers expansion because grow() is called when size is equal to elementData.length. The first add allocates 10 capacity, and subsequent expansion is 1.5 times and not less than the minimum requirement, relying on delayed initialization and System.arraycopy optimization.
How to safely read a line of integer input in Java and avoid Scanner blocking
Mar 06, 2026 am 06:21 AM
This article introduces typical blocking problems when using Scanner to read multiple integers in a single line. It points out that hasNextInt() will wait indefinitely when there is no subsequent input, and recommends a safe alternative with nextLine() string splitting as the core.
