Fechamento de Streams em Java

Ao trabalhar com streams para interagir com recursos externos, como arquivos ou conexões de rede, é fundamental garantir que esses recursos sejam liberados assim que não forem mais necessários. Em Java, isso é feito fechando o stream através do método close().

Este método é definido na interface Closeable e possui a seguinte assinatura:

void close() throws IOException

A interface Closeable é implementada pelas classes base InputStream e OutputStream e, por consequência, por todas as classes de stream que herdam delas.

Quando um stream é fechado, os recursos do sistema alocados para ele — como descritores de arquivo (file descriptors) — são devolvidos ao sistema operacional. Se um stream não for fechado, esses recursos permanecem ocupados, causando um vazamento de recursos (resource leak). Em aplicações que manipulam muitos arquivos ou conexões, isso pode levar ao esgotamento de recursos e causar falhas.

Existem duas abordagens principais para garantir que um stream seja sempre fechado corretamente.

A Abordagem Clássica: O Bloco try-catch-finally

A maneira tradicional de gerenciar recursos é utilizando um bloco try-catch-finally. A lógica de manipulação do stream fica no bloco try, o tratamento de exceções no catch, e a limpeza de recursos no finally. O bloco finally é crucial porque seu código é executado sempre, tenha ocorrido uma exceção ou não.

Veja um exemplo de leitura de arquivo usando essa estrutura:

import java.io.*;

public class Program {

    public static void main(String[] args) {

        FileInputStream fin = null;
        try {
            fin = new FileInputStream("notes.txt");

            int i;
            while ((i = fin.read()) != -1) {
                System.out.print((char) i);
            }
        } catch (IOException ex) {
            System.out.println(ex.getMessage());
        } finally {
            try {
                // A verificação '!= null' é essencial
                if (fin != null) {
                    fin.close();
                }
            } catch (IOException ex) {
                System.out.println(ex.getMessage());
            }
        }
    }
}

Neste código, a verificação if (fin != null) dentro do finally é vital. Se a criação do FileInputStream falhar (por exemplo, se o arquivo não existir), a variável fin permanecerá nula. Sem a verificação, uma tentativa de chamar fin.close() resultaria em uma NullPointerException, mascarando a exceção original. Além disso, como o próprio método close() pode lançar uma IOException, ele também precisa ser envolvido por um try-catch, tornando o código verboso e propenso a erros.

A Abordagem Moderna: try-with-resources

Introduzida no Java 7, a estrutura try-with-resources é a forma moderna e recomendada para gerenciar recursos. Ela fecha automaticamente qualquer recurso que implemente a interface AutoCloseable (da qual Closeable herda).

Vamos reescrever o exemplo anterior usando essa abordagem limpa e segura:

import java.io.*;

public class Program {

    public static void main(String[] args) {

        try (FileInputStream fin = new FileInputStream("notes.txt")) {
            int i;
            while ((i = fin.read()) != -1) {
                System.out.print((char) i);
            }
        } catch (IOException ex) {
            System.out.println(ex.getMessage());
        }
    }
}

A sintaxe é try (ResourceType resource = new ResourceType()). O recurso é declarado e inicializado dentro dos parênteses após a palavra-chave try. Ao final da execução do bloco, o método close() do recurso é chamado automaticamente pela JVM, seja a execução concluída com sucesso ou interrompida por uma exceção.

Essa estrutura elimina a necessidade do bloco finally e de verificações de nulidade, resultando em um código mais conciso, legível e seguro.

É possível declarar múltiplos recursos em um único bloco, separando-os por ponto e vírgula. Todos serão fechados na ordem inversa de sua declaração.

try (FileInputStream fin = new FileInputStream("source.txt");
     FileOutputStream fos = new FileOutputStream("destination.txt")) {
    // Código para ler de 'fin' e escrever em 'fos'
} catch (IOException e) {
    // Tratamento de exceção para ambos os recursos
}

Resumo

• É fundamental fechar streams para liberar recursos do sistema e evitar vazamentos (resource leaks).
• A abordagem tradicional com try-catch-finally é funcional, mas verbosa e propensa a erros, como NullPointerException ou mascaramento de exceções.
• A estrutura try-with-resources, disponível desde o Java 7, é o padrão moderno e recomendado para o gerenciamento de recursos.
• O try-with-resources fecha os recursos automaticamente, tornando o código mais limpo, seguro e legível.