Fundamentos de java.io e java.nio: diferenças e evolução da API

1. Como o Java aprendeu a trabalhar com arquivos

Java e arquivos: por onde tudo começou

Certa vez, lá em 1996, os desenvolvedores da linguagem propuseram a primeira forma de trabalhar com arquivos — o pacote java.io. Nele surgiram classes como File, FileInputStream, FileOutputStream, Reader, Writer e outras. Essas classes permitiam diversas operações com arquivos: verificar se o arquivo existe, seu tamanho, a data de modificação e trabalhar com diretórios.

Mas, como é comum nas primeiras versões, não era perfeito — muita coisa podia ser mais prática e segura.

Limitações da API antiga (java.io)

• File — não é um arquivo, e sim um “atalho”. A classe File não lê nem escreve conteúdo. Ela descreve o caminho e metadados. Para leitura/escrita são necessários streams separados: FileInputStream/FileOutputStream ou Reader/Writer.
• Trabalhar com caminhos — é doloroso. Concatenar caminhos manualmente como "C:\\Users\\" + user + "\\Documents" muitas vezes quebrava ao portar entre Windows e Linux.
• Sem suporte a links simbólicos. A API antiga não entendia symlinks e podia lidar com eles de forma incorreta.
• Suporte fraco a atributos. Difícil obter permissões, proprietário, flags como “oculto” etc.
• Ineficiente para arquivos grandes. Os streams clássicos não ofereciam cenários práticos e rápidos para grandes volumes de dados; não havia I/O assíncrono.

O surgimento de java.nio.file (NIO.2, Java 7)

No Java 7 surgiu um novo pacote: java.nio.file (frequentemente — NIO.2). Ele trouxe:

• Path — uma abstração moderna de caminho (incluindo caminhos dentro de ZIP, sistemas de arquivos em nuvem e de rede).
• Files — utilitários estáticos para leitura, escrita, cópia e exclusão.
• FileSystem — trabalho não só com disco local, mas também com outros sistemas de arquivos.
• Suporte a links simbólicos, atributos estendidos e permissões.
• I/O assíncrono e desempenho melhor para grandes volumes de dados.
• Trabalho conveniente com diretórios e APIs baseadas em streams.

NIO significa “New Input/Output” e, embora já tenha mais de dez anos, ainda é o padrão moderno no ecossistema Java.

2. Comparação de abordagens: java.io vs java.nio.file

Classe File (java.io)

• Representa o caminho de um arquivo ou diretório e seus metadados.
• Não lê/escreve o conteúdo do arquivo.
• Permite verificar existência, tamanho, tipo (arquivo/diretório), caminho absoluto etc.

import java.io.File;

public class ExampleIO {
    public static void main(String[] args) {
        File file = new File("example.txt");
        if (file.exists()) {
            System.out.println("O arquivo existe!");
            System.out.println("Tamanho: " + file.length() + " bytes");
        }
    }
}

Classe Path (java.nio.file)

• Abstração moderna de caminho, combina e normaliza naturalmente.
• Pode representar caminhos locais, de arquivo compactado e de rede.

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

public class ExampleNIOPath {
    public static void main(String[] args) throws Exception {
        Path path = Paths.get("example.txt");
        if (Files.exists(path)) {
            System.out.println("Arquivo encontrado!");
            System.out.println("Tamanho: " + Files.size(path) + " bytes");
        }
    }
}

Classe Files (java.nio.file)

• Conjunto de métodos estáticos para leitura/escrita inteira e parcial.
• Cópia, exclusão e movimentação de arquivos.
• Criação/remoção de diretórios.
• Acesso a atributos estendidos.

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;

public class ExampleNIOFiles {
    public static void main(String[] args) throws Exception {
        Path path = Paths.get("example.txt");
        List<String> lines = Files.readAllLines(path);
        for (String line : lines) {
            System.out.println(line);
        }
    }
}

Tabela comparativa

java.io.File

java.nio.file.Path + Files

3. Quando usar o quê?

API antiga (java.io): quando ela é necessária?

• Para dar suporte a código legado. Se o projeto começou antes do Java 7 e usa File, FileInputStream, FileOutputStream, talvez seja preciso manter a compatibilidade.
• Em projetos novos — não é recomendado. Usar o “veterano” File hoje é como assistir a vídeos em fitas VHS.

API nova (java.nio.file): padrão moderno

• Sempre prefira Path e Files em projetos novos.
• Mais simples, seguro, poderoso e melhor integrado a streams, lambdas e try-with-resources.

Guia rápido

• Leitura, gravação, cópia, exclusão? — via Files.
• Manipulação de caminhos (junção, normalização)? — via Path.
• Tamanho, data, permissões? — Files.getAttribute() e métodos relacionados.
• Percorrer diretórios, recursivamente? — Files.walk, Files.list.

4. Exemplos: como o código ficaria na API antiga e na nova

Exemplo 1: Verificação de existência de arquivo

Modo antigo:

import java.io.File;

File file = new File("data.txt");
if (file.exists()) {
    System.out.println("Arquivo encontrado!");
}

Modo novo:

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

Path path = Paths.get("data.txt");
if (Files.exists(path)) {
    System.out.println("Arquivo encontrado!");
}

Exemplo 2: Leitura de todas as linhas de um arquivo

Modo antigo:

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;

File file = new File("data.txt");
BufferedReader reader = new BufferedReader(new FileReader(file));
String line;
while ((line = reader.readLine()) != null) {
    System.out.println(line);
}
reader.close();

Modo novo:

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;

Path path = Paths.get("data.txt");
List<String> lines = Files.readAllLines(path);
for (String line : lines) {
    System.out.println(line);
}

Comentário: O modo novo é mais curto e seguro; com try-with-resources o gerenciamento de recursos fica ainda mais simples.

Exemplo 3: Escrita de uma linha em um arquivo

Modo antigo:

import java.io.FileWriter;

FileWriter writer = new FileWriter("output.txt");
writer.write("Olá, arquivo!");
writer.close();

Modo novo:

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

Path path = Paths.get("output.txt");
Files.write(path, "Olá, arquivo!".getBytes());

5. Nuances úteis

Por que o Java decidiu refazer tudo?

• Segurança e confiabilidade. Menos erros com fechamento de recursos e caminhos.
• Multiplataforma. Mesmas classes para Windows, Linux e até arquivos ZIP.
• Facilidade de extensão. Mais fácil adicionar suporte a sistemas de arquivos em nuvem e de rede.
• Desempenho. Melhor comportamento em arquivos grandes e operações assíncronas.
• Compatibilidade com o stack moderno do Java. Lambdas, streams, try-with-resources.

Como migrar da API antiga para a nova?

Quase sempre é possível converter File em Path e vice-versa:

File file = new File("data.txt");
Path path = file.toPath();
File file2 = path.toFile();

O que fazer ao encontrar código antigo?

• Não se assuste: dá para fazer tudo de forma mais simples e moderna.
• Havendo possibilidade — reescreva usando java.nio.file.
• Não sendo possível — use as pontes (toPath(), toFile()) e migre gradualmente.

6. Exemplo final: miniaplicativo

Exemplo: Verificamos se o arquivo existe e exibimos seu tamanho.

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

public class FileInfo {
    public static void main(String[] args) {
        Path path = Paths.get("test.txt");
        if (Files.exists(path)) {
            try {
                long size = Files.size(path);
                System.out.println("Arquivo encontrado. Tamanho: " + size + " bytes");
            } catch (Exception e) {
                System.out.println("Erro ao obter o tamanho do arquivo: " + e.getMessage());
            }
        } else {
            System.out.println("Arquivo não encontrado!");
        }
    }
}

O que usamos aqui:

• Path — representação de caminho.
• Files.exists() — verificação de existência.
• Files.size() — obtenção do tamanho.

7. Erros comuns ao trabalhar com APIs de arquivos

Erro №1: esperar que File possa ler ou escrever conteúdo. Na verdade, File é apenas um “atalho”. Para leitura/gravação, use FileInputStream/FileOutputStream (API antiga) ou os utilitários de Files (API nova).

Erro №2: concatenar caminhos manualmente com + ou barra. Isso leva a erros em diferentes SOs. Use Path.resolve() ou Paths.get(...) com vários argumentos.

Erro №3: esquecer de fechar o stream. Na API antiga, isso é uma causa frequente de vazamento de recursos. Na API nova, muitas operações via Files não criam streams e, onde eles são necessários, aplique try-with-resources.

Erro №4: usar a API antiga em projetos novos. Se você está iniciando um projeto novo — escolha java.nio.file. Recorrer a java.io só faz sentido para compatibilidade com código legado.