Classes File, Path, Files: visão geral, criação de objetos

1. Classe File: como tudo começou

Embora já tenhamos concluído que a classe File é melhor não usar em novos projetos, existem muitos sistemas legados em que ela é aplicada. Portanto, é importante entendê-la e saber utilizá-la. A classe File é uma forma antiga de representar um arquivo ou diretório no disco. Mas não confunda: o objeto File não é o arquivo em si, é apenas um “ponteiro”/descritor de caminho. Por exemplo, a expressão File f = new File("hello.txt"); não cria um arquivo no disco — você apenas descreveu o caminho.

Como criar um objeto File?

import java.io.File;

public class FileDemo {
    public static void main(String[] args) {
        File file = new File("example.txt"); // caminho relativo
        File folder = new File("mydir");     // diretório

        System.out.println("Caminho absoluto: " + file.getAbsolutePath());
        System.out.println("O arquivo existe? " + file.exists());
        System.out.println("É um arquivo? " + file.isFile());
        System.out.println("É um diretório? " + folder.isDirectory());
    }
}

O que é importante lembrar:
Criar um objeto File não cria um arquivo no disco. É apenas um “atalho”. Para o arquivo realmente aparecer, é preciso criar explicitamente (por exemplo, gravar dados ou chamar file.createNewFile()).

Métodos principais da classe File

• exists() — verifica se o arquivo/diretório existe.
• isFile() — é um arquivo (e não uma pasta)?
• isDirectory() — é um diretório?
• getAbsolutePath() — obter o caminho absoluto.
• length() — tamanho do arquivo em bytes.
• getName() — nome do arquivo ou pasta.
• delete() — excluir arquivo/diretório (se estiver vazio).

Exemplo: exibindo informações do arquivo

File file = new File("example.txt");
System.out.println("Nome: " + file.getName());
System.out.println("Caminho: " + file.getAbsolutePath());
System.out.println("Tamanho: " + file.length() + " bytes");
System.out.println("Existe? " + file.exists());

2. Classe Path: uma visão moderna de arquivos

Path é parte da nova API de arquivos (NIO.2, desde o Java 7). É uma abstração do caminho para um arquivo/diretório, e o caminho pode estar não apenas no disco local, mas também, por exemplo, dentro de um arquivo ZIP ou em um recurso remoto (se houver um provedor correspondente).

Se File é um mapa de papel antigo, então Path é um GPS.

Como criar um objeto Path?

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

public class PathDemo {
    public static void main(String[] args) {
        Path path1 = Paths.get("example.txt"); // caminho relativo
        Path path2 = Paths.get("folder", "file.txt"); // juntando partes do caminho

        System.out.println("Caminho 1: " + path1.toAbsolutePath());
        System.out.println("Caminho 2: " + path2.toAbsolutePath());
    }
}

Vantagem: você não precisa se preocupar com separadores. Paths.get escolherá o formato correto para o seu SO.

Conversão entre File e Path

• File → Path: file.toPath()
• Path → File: path.toFile()

File file = new File("test.txt");
Path path = file.toPath();

Path anotherPath = Paths.get("data.txt");
File anotherFile = anotherPath.toFile();

Trabalhando com caminhos: resolve, relativize, normalize

Juntando caminhos (resolve)

Path dir = Paths.get("myfolder");
Path file = dir.resolve("notes.txt"); // myfolder/notes.txt
System.out.println(file); // myfolder/notes.txt

Caminho relativo (relativize)

Path pathA = Paths.get("folderA/file1.txt");
Path pathB = Paths.get("folderA/subfolder/file2.txt");
Path relative = pathA.relativize(pathB);
System.out.println(relative); // ../subfolder/file2.txt

Normalização do caminho (normalize)

Path messy = Paths.get("folder/../folder/file.txt");
Path clean = messy.normalize();
System.out.println(clean); // folder/file.txt

Exemplo: construindo o caminho para um arquivo

Path home = Paths.get(System.getProperty("user.home"));
Path docs = home.resolve("Documents");
Path myFile = docs.resolve("myfile.txt");
System.out.println("Caminho para o arquivo: " + myFile.toAbsolutePath());

3. Classe Files: seu canivete suíço

A classe Files do pacote java.nio.file é um conjunto utilitário de métodos estáticos para trabalhar com arquivos e diretórios sobre Path. Ela faz praticamente tudo: verificar existência, criar/excluir, ler/gravar, copiar/mover, obter atributos e percorrer a árvore de diretórios.

Métodos principais da classe Files

• Files.exists(path) — verifica se o arquivo/diretório existe.
• Files.isDirectory(path) — é um diretório?
• Files.size(path) — tamanho do arquivo.
• Files.createFile(path) — criar arquivo.
• Files.createDirectory(path) — criar diretório.
• Files.delete(path) — excluir arquivo/diretório.
• Files.copy(src, dest) — copiar arquivo.
• Files.move(src, dest) — mover/renomear.
• Files.getLastModifiedTime(path) — hora da última modificação.
• Files.readAllBytes(path) — ler o arquivo inteiro como array de bytes.
• Files.readAllLines(path) — ler todas as linhas de um arquivo de texto.
• Files.write(path, bytes) — gravar bytes em um arquivo.

Exemplo: verificando arquivo

import java.nio.file.*;

public class FilesDemo {
    public static void main(String[] args) {
        Path path = Paths.get("example.txt");

        System.out.println("O arquivo existe? " + Files.exists(path));
        System.out.println("É um diretório? " + Files.isDirectory(path));

        if (Files.exists(path)) {
            try {
                System.out.println("Tamanho do arquivo: " + Files.size(path) + " bytes");
            } catch (Exception e) {
                System.out.println("Erro ao obter o tamanho: " + e.getMessage());
            }
        }
    }
}

4. Prática: criando objetos e exibindo propriedades

Criando objetos para arquivo e diretório

import java.io.File;
import java.nio.file.Path;
import java.nio.file.Paths;

public class CompareDemo {
    public static void main(String[] args) {
        // Maneira antiga
        File oldFile = new File("test.txt");
        File oldDir = new File("mydir");

        // Maneira nova
        Path newFile = Paths.get("test.txt");
        Path newDir = Paths.get("mydir");

        System.out.println("=== File API ===");
        System.out.println("Arquivo: " + oldFile.getAbsolutePath());
        System.out.println("Existe? " + oldFile.exists());
        System.out.println("É um arquivo? " + oldFile.isFile());
        System.out.println("É um diretório? " + oldDir.isDirectory());

        System.out.println("\n=== Path API ===");
        System.out.println("Arquivo: " + newFile.toAbsolutePath());
        System.out.println("Existe? " + java.nio.file.Files.exists(newFile));
        System.out.println("É um arquivo? " + java.nio.file.Files.isRegularFile(newFile));
        System.out.println("É um diretório? " + java.nio.file.Files.isDirectory(newDir));
    }
}

Exibindo propriedades do arquivo

import java.nio.file.*;

public class FileProperties {
    public static void main(String[] args) {
        Path path = Paths.get("test.txt");

        System.out.println("Caminho absoluto: " + path.toAbsolutePath());
        System.out.println("Nome do arquivo: " + path.getFileName());
        System.out.println("Diretório pai: " + path.getParent());

        if (Files.exists(path)) {
            try {
                System.out.println("Tamanho: " + Files.size(path) + " bytes");
                System.out.println("Última modificação: " + Files.getLastModifiedTime(path));
            } catch (Exception e) {
                System.out.println("Erro ao obter as informações: " + e.getMessage());
            }
        } else {
            System.out.println("Arquivo não encontrado.");
        }
    }
}

5. Comparação: File vs Path/Files

Resumo: quando usar o quê?

• Para novos projetos — use Path e Files.
• Para manter código legado — às vezes será necessário trabalhar com File.

6. Nuances úteis

Caminhos relativos e absolutos

Um caminho relativo é relativo ao diretório de trabalho atual; o absoluto é o caminho completo a partir da raiz do sistema de arquivos.

Path relative = Paths.get("data", "file.txt");
Path absolute = relative.toAbsolutePath();
System.out.println("Caminho absoluto: " + absolute);

Multiplataforma

Path e Files levam em conta as particularidades do SO (separadores, codificações etc.). Não escreva caminhos manualmente do tipo "C:\\folder\\file.txt" — use Paths.get e resolve.

Conversão entre File e Path

Se você tem código antigo com File, é fácil migrar para a nova API:

File legacy = new File("legacy.txt");
Path modern = legacy.toPath();
if (Files.exists(modern)) {
    // Agora você pode usar todos os recursos do NIO.2
}

Verificando a existência de um arquivo

Path path = Paths.get("notes.txt");
if (Files.exists(path)) {
    System.out.println("Arquivo encontrado!");
} else {
    System.out.println("O arquivo não existe.");
}

7. Mini prática: criando e verificando arquivo e diretório

import java.nio.file.*;

public class MiniPractice {
    public static void main(String[] args) throws Exception {
        Path dir = Paths.get("demo_dir");
        Path file = dir.resolve("hello.txt");

        // Criamos o diretório, se ele não existir
        if (!Files.exists(dir)) {
            Files.createDirectory(dir);
            System.out.println("Diretório criado: " + dir.toAbsolutePath());
        }

        // Criamos o arquivo, se ele não existir
        if (!Files.exists(file)) {
            Files.createFile(file);
            System.out.println("Arquivo criado: " + file.toAbsolutePath());
        }

        // Exibimos as propriedades
        System.out.println("O arquivo existe? " + Files.exists(file));
        System.out.println("É um arquivo? " + Files.isRegularFile(file));
        System.out.println("Tamanho: " + Files.size(file) + " bytes");

        // Excluímos o arquivo e o diretório (se desejar)
        Files.delete(file);
        Files.delete(dir);
        System.out.println("Arquivo e diretório excluídos.");
    }
}

8. Erros comuns ao trabalhar com File/Path/Files

Erro nº 1: confusão entre File e Path. Muitos iniciantes tentam usar os métodos Files com um objeto File. Lembre-se: Files.* funciona com Path. Se você tem um File, primeiro faça file.toPath().

Erro nº 2: esperar que criar um objeto File ou Path crie o arquivo. Um objeto de caminho é um atalho, não um arquivo real. Para criar, use Files.createFile(path) ou grave dados.

Erro nº 3: montar caminhos manualmente como string. Não escreva "folder/file.txt" ou "folder\\file.txt". Use Paths.get(...) e resolve(...). É mais seguro e multiplataforma.

Erro nº 4: ignorar exceções. Operações com arquivos lançam IOException e outras exceções. Trate-as com try-catch ou propague (throws).

Erro nº 5: verificar com File.exists(), e depois trabalhar com Path. Procure manter um único estilo: começou com Path — use Files.exists(path) e os demais métodos de Files.