Core Java

Try-with-resources in Java 7 is a new way of exception handling which makes it easier to automatically close resources that are used within a try-catch block.

A resource is an object that must be closed after using it.

Example : A file resource for file IO operations, JDBC resource for database connection etc.

Before this feature introduced in Java 7, there was no auto resource management in java and we had to explicitly close the resource after using the resource.

Generally, we do that in the finally block of a try-catch statement.

This approach was causing lot of memory leaks and performance hit when we forgot to close the resource.

Let’s look at the below example

  1. private static void readFile() throws IOException {
  2.     InputStream input = null;
  4.     try {
  5.         input = new FileInputStream("sample.txt");
  7.         int data =;
  8.         while(data != -1){
  9.             System.out.print((char) data);
  10.             data =;
  11.         }
  12.     } finally {
  13.         if(input != null){
  14.             input.close();
  15.         }
  16.     }
  17. }
private static void readFile() throws IOException {
    InputStream input = null;

    try {
        input = new FileInputStream("sample.txt");

        int data =;
        while(data != -1){
            System.out.print((char) data);
            data =;
    } finally {
        if(input != null){

In the above program, we can see that exception might be thrown in try block in few places like while opening and reading the file

We have used finally block to close resources, it will make sure that code will always be executed no matter exception occurs or not.
If an exception is thrown in the try block then finally block will be executed to close the resource.

What if an exception occurs in finally block while closing the resource?

The exception thrown from the finally block would be propagated to the caller, even though the exception thrown from the try block is more relevant to propagate.

This will kill the actual root cause of exception and throw other exception from finally block.

Let’s do the same in Java 7 try with resource

In Java 7 we can write the above code using try-with-resource construct like this:

  1. private static void readFileJava7() throws IOException {
  3.     try(FileInputStream input = new FileInputStream("file.txt")) {
  5.         int data =;
  6.         while(data != -1){
  7.             System.out.print((char) data);
  8.             data =;
  9.         }
  10.     }
  11. }
private static void readFileJava7() throws IOException {

    try(FileInputStream input = new FileInputStream("file.txt")) {

        int data =;
        while(data != -1){
            System.out.print((char) data);
            data =;

We can see that the way try block is started,

    try(FileInputStream input = new FileInputStream("file.txt")) {

This way of writing “try” is called try-with-resources

The FileInputStream variable is instantiated and assigned to the variable inside try parenthesis

When the try block completes execution, the FileInputStream will be closed automatically.

This is possible because FileInputStream implements the Java interface java.lang.AutoCloseable.

All classes implementing this interface can be used inside the try-with-resources construct and it will be closed automatically by Java.

So this way, we don’t even need to write finally block to close the resource.

Even if we forget to close resources, Java takes care of it.

We can also use multiple resources within try as below

  1. private static void readFileJava7() throws IOException {
  3.     try(  FileInputStream input = new FileInputStream("file.txt");
  4.           BufferedInputStream bufferedInputStream = new BufferedInputStream(input)
  5.     )
  6.  {
  8.         int data =;
  9.         while(data != -1){
  10.             System.out.print((char) data);
  11.     data =;
  12.         }
  13.     }
  14. }
private static void readFileJava7() throws IOException {

    try(  FileInputStream input = new FileInputStream("file.txt");
          BufferedInputStream bufferedInputStream = new BufferedInputStream(input)

        int data =;
        while(data != -1){
            System.out.print((char) data);
    data =;

The above program creates 2 resources inside the parentheses after the try keyword.
1. FileInputStream
2. BufferedInputStream.

Both of these resources will be closed automatically when try block completes execution.

Note :
The resources will be closed in reverse order of the order in which they are created inside the try parentheses. So in above example, First the BufferedInputStream will be closed, then the FileInputStream will be closed.
Share this article on

Comment (9)

    1. Karibasappa G C (KB)
      Karibasappa G C (KB)

      First thing, static variables will never be a part of method, it will be a part of class always.

      So only we cant declare any static variables inside a method but we can access them inside a method.

      All static variables will be stored in separate segment inside Heap area only.

      1. The blog is very helpful. Thanks a lot for sharing! Also the “Inheritance in interface” page is not opening. Can you please fix that?

Leave a Comment

  • You may use these HTML tags and attributes: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code lang=""> <del datetime=""> <em> <i> <q cite=""> <s> <strike> <strong> <pre lang="" extra="">

    • Please answer this simple challenge to post your valuable comment *