¿Estoy usando Java 7 try-with-resources correctamente?

Estoy esperando que el lector y el lector de archivos almacenados en el búfer se cierren y los recursos se liberen si se lanza la excepción.

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

Sin embargo, ¿existe un requisito de tener una cláusula de catch para el cierre exitoso?

EDITAR:

Básicamente, el código anterior en Java 7 es equivalente al siguiente para 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; } 

    Es correcto y no hay ningún requisito para la cláusula catch . Oracle java 7 doc dice que el recurso se cerrará independientemente de si se ha lanzado una excepción o no.

    Debería usar una cláusula de catch solo si desea reactjsr ante la excepción. La cláusula catch se ejecutará después de que se cierre el recurso.

    Aquí hay un fragmento del tutorial de Oracle :

    El siguiente ejemplo lee la primera línea de un archivo. Utiliza una instancia de BufferedReader para leer datos del archivo. BufferedReader es un recurso que debe cerrarse después de que el progtwig haya terminado con él:

     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. 

    … Dado que la instancia de BufferedReader se declara en una instrucción try-with-resource, se cerrará independientemente de si la instrucción try se completa de forma normal o abrupta (como resultado del método BufferedReader.readLine que arroja una IOException).

    EDITAR

    En cuanto a la nueva pregunta editada:

    El código en Java 6 ejecuta la catch y luego el bloque finally . Esto hace que los recursos aún se puedan abrir potencialmente en el bloque catch .

    En la syntax de Java 7, los recursos se cierran antes del bloque catch , por lo que los recursos ya están cerrados durante la ejecución del bloque catch . Esto está documentado en el enlace de arriba:

    En una instrucción try-with-resources, cualquier bloque catch o finally se ejecuta después de que se hayan cerrado los recursos declarados.

    Su uso de try-with-resources funcionará bien en este caso particular, pero no es del todo correcto en general. No deberías encadenar recursos así porque pueden generar sorpresas desagradables. Supongamos que tiene un tamaño de búfer variable:

     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); } } 

    Supongamos que algo salió mal y terminaste con sz siendo negativo. En este caso, su recurso de archivo (creado a través de new FileReader(filePath) ) NO se cerrará.

    Para evitar este problema, debe especificar cada recurso por separado de esta manera:

     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); } } 

    En este caso, incluso si la inicialización de br falla, el file aún se cierra. Puede encontrar más detalles aquí y aquí .