Am I using the Java 7 try-with-resources correctly

I am expecting the buffered reader and file reader to close and the resources released if the exception is throw.

public static Object[] fromFile(String filePath) throws FileNotFoundException, IOException
{
	try (BufferedReader br = new BufferedReader(new FileReader(filePath)))
	{
		return read(br);
	} 
}

However, is there a requirement to have a catch clause for successful closure?

EDIT:

Essentially, is the above code in Java 7 equivalent to the below for Java 6:

public static Object[] fromFile(String filePath) throws FileNotFoundException, IOException
{

    BufferedReader br = null;

    try
    {
    	br = new BufferedReader(new FileReader(filePath));
	
        return read(br);
    }
	catch (Exception ex)
	{
		throw ex;
	}
	finally
	{
		try
		{
			if (br != null) br.close();
		}
		catch(Exception ex)
		{
		}
	}
	
	return null;
}

It's correct and there's no requirement for catch clause. Oracle java 7 doc says the resource will be closed regardless of whether an exception is actually thrown or not.

You should use a catch clause only if you want to react upon the exception. The catch clause will be executed after the resource is closed.

Here's a snippet from Oracle's tutorial:

> 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:

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.

> ... 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).

EDIT

Regarding the new edited question:

The code in Java 6 executes the catch and afterwards the finally block. This causes the resources to be still potentially opened in the catch block.

In Java 7 syntax, resources are closed before the catch block, so resources are already closed during the catch block execution. This is documented in the above link:

> In a try-with-resources statement, any catch or finally block is run > after the resources declared have been closed.

Your usage of try-with-resources will work fine in this particular case, but it is not quite correct in general. You should not chain resources like that because it may lead to unpleasant surprises. Assume you have a variable buffer size:

public static Object[] fromFile(String filePath) throws FileNotFoundException, IOException
{
    int sz = /* get buffer size somehow */
    try (BufferedReader br = new BufferedReader(new FileReader(filePath), sz))
    {
        return read(br);
    } 
}

Assume something went wrong and you ended up with sz being negative. In this case your file resource (created via new FileReader(filePath)) will NOT be closed.

To avoid this problem you should specify each resource separately like this:

public static Object[] fromFile(String filePath) throws FileNotFoundException, IOException
{
    int sz = /* get buffer size somehow */
    try (FileReader file = new FileReader(filePath);
         BufferedReader br = new BufferedReader(file, sz))
    {
        return read(br);
    } 
}

In this case even if initialization of br fails file still gets closed. You can find more details here and here.