Criação e exclusão de arquivos e pastas

1. Criação de arquivos

Criar arquivos programaticamente é algo frequente: para logs, dados temporários, exportação de relatórios, importação de dados, salvamento de configurações e muito mais. Em Java, para isso, como você provavelmente já imaginou, é melhor usar a API moderna — java.nio.file.

Ferramenta principal: Files.createFile(Path)

Este método cria um novo arquivo no caminho especificado. Se o arquivo já existir, uma exceção será lançada.

Exemplo: criamos um arquivo de texto no diretório atual

import java.nio.file.*;

public class CreateFileExample {
    public static void main(String[] args) {
        Path path = Path.of("hello.txt");
        try {
            Files.createFile(path);
            System.out.println("Arquivo criado: " + path.toAbsolutePath());
        } catch (FileAlreadyExistsException e) {
            System.out.println("O arquivo já existe: " + path);
        } catch (Exception e) {
            System.out.println("Erro ao criar o arquivo: " + e.getMessage());
        }
    }
}

Observe:
Files.createFile lança FileAlreadyExistsException se o arquivo já existir. Por isso, muitas vezes verifica-se a existência antes de criar o arquivo.

Verificação de existência do arquivo

Path path = Path.of("hello.txt");
if (!Files.exists(path)) {
    Files.createFile(path);
}

Dica:
Verificar a existência do arquivo não protege contra condições de corrida entre threads, mas para a maioria dos cenários de usuário é um método totalmente válido.

Em resumo: o que acontece ao criar um arquivo?

• Se o arquivo não existir e o caminho for válido — um novo arquivo vazio é criado.
• Se o arquivo já existir — é lançada uma exceção.
• Se o caminho for inválido, não houver permissões ou a pasta não existir — outra exceção será lançada (IOException, NoSuchFileException etc.).

2. Criação de diretórios

Diferença entre Files.createDirectory e Files.createDirectories

• Files.createDirectory(Path) — cria apenas uma pasta. Se a pasta pai não existir — ocorrerá um erro.
• Files.createDirectories(Path) — cria toda a cadeia de pastas ausentes (como um mágico que constrói a escada bem debaixo dos seus pés).

Exemplo: criamos uma única pasta

Path dir = Path.of("data");
try {
    Files.createDirectory(dir);
    System.out.println("Pasta criada: " + dir.toAbsolutePath());
} catch (FileAlreadyExistsException e) {
    System.out.println("A pasta já existe: " + dir);
} catch (Exception e) {
    System.out.println("Erro ao criar a pasta: " + e.getMessage());
}

Exemplo: criamos uma estrutura de pastas aninhadas

Path nested = Path.of("data/reports/2024");
try {
    Files.createDirectories(nested);
    System.out.println("Estrutura de pastas criada: " + nested.toAbsolutePath());
} catch (Exception e) {
    System.out.println("Erro ao criar a estrutura: " + e.getMessage());
}

Observe que: se alguma pasta já existir, createDirectories não se incomoda — ele simplesmente cria as que faltam. Se você usar createDirectory para uma pasta aninhada e a pasta pai ainda não existir — ocorrerá um erro.

Tabela: comparação dos métodos de criação de pastas

createDirectory

createDirectories

3. Exclusão de arquivos

Excluir arquivos é quase como jogar o lixo fora: o principal — não jogar algo necessário! No Java, há dois métodos principais para isso:

• Files.delete(Path) — exclui um arquivo ou uma pasta vazia. Se o arquivo não existir — será lançada uma exceção.
• Files.deleteIfExists(Path) — exclui o arquivo, mas, se ele não existir — simplesmente não faz nada.

Exemplo: excluímos um arquivo temporário

Path tempFile = Path.of("temp.txt");
try {
    Files.delete(tempFile);
    System.out.println("Arquivo excluído: " + tempFile);
} catch (NoSuchFileException e) {
    System.out.println("Arquivo não encontrado: " + tempFile);
} catch (DirectoryNotEmptyException e) {
    System.out.println("A pasta não está vazia: " + tempFile);
} catch (Exception e) {
    System.out.println("Erro ao excluir: " + e.getMessage());
}

Opção mais segura

boolean deleted = Files.deleteIfExists(tempFile);
if (deleted) {
    System.out.println("O arquivo foi excluído.");
} else {
    System.out.println("Arquivo não encontrado — nada para excluir.");
}

Importante!

• Se o arquivo estiver aberto em outro programa — pode ser lançada uma exceção (por exemplo, no Windows).
• Se tentar excluir uma pasta que não está vazia — ocorrerá o erro DirectoryNotEmptyException.

4. Exclusão de diretórios

Pastas no Java são excluídas de forma semelhante aos arquivos. Com um único detalhe: os métodos padrão excluem apenas pastas vazias.

Exemplo: excluímos uma pasta vazia

Path emptyDir = Path.of("empty_folder");
try {
    Files.delete(emptyDir);
    System.out.println("Pasta excluída: " + emptyDir);
} catch (DirectoryNotEmptyException e) {
    System.out.println("A pasta não está vazia: " + emptyDir);
} catch (NoSuchFileException e) {
    System.out.println("Pasta não encontrada: " + emptyDir);
} catch (Exception e) {
    System.out.println("Erro ao excluir a pasta: " + e.getMessage());
}

O que fazer com pastas não vazias?

Para excluir diretórios não vazios, será necessário excluir recursivamente todos os arquivos e subpastas. Este é um tema para uma aula à parte (e uma aventura à parte), mas, se você já estiver com pressa, aqui vai o código — estude e tente reproduzir:

import java.nio.file.*;
import java.io.IOException;

public class DeleteDirectoryRecursively {
    public static void deleteRecursively(Path path) throws IOException {
        if (Files.isDirectory(path)) {
            try (var entries = Files.list(path)) {
                for (Path entry : entries.toList()) {
                    deleteRecursively(entry);
                }
            }
        }
        Files.delete(path);
    }
}

Atenção:
Este código apagará tudo que estiver dentro da pasta! Use com cuidado.

5. Dicas práticas

Verificação de existência antes da exclusão

if (Files.exists(path)) {
    Files.delete(path);
} else {
    System.out.println("Arquivo/pasta não existe.");
}

Mas, se você usar deleteIfExists, isso não é obrigatório.

Tratamento de exceções

Ao trabalhar com arquivos, frequentemente nos deparamos com imprevistos. O Java lança diferentes exceções para isso:

• NoSuchFileException — arquivo ou pasta não encontrados. Por exemplo, você tenta abrir algo que já foi excluído.
• DirectoryNotEmptyException — você quer excluir uma pasta, mas ainda há algo dentro dela.
• IOException — um aviso genérico: algo deu errado. A causa pode variar — falta de permissões, arquivo em uso por outro programa, caminho inválido.

Esquema visual: métodos principais

+-------------------+         +--------------------+
| Files.createFile  | ---->   |    Novo arquivo    |
+-------------------+         +--------------------+

+---------------------+       +--------------------+
| Files.createDirectory|----> |     Nova pasta     |
+---------------------+       +--------------------+

+-------------------+         +----------------------------+
| Files.delete      | ---->   | Arquivo/pasta excluído     |
+-------------------+         +----------------------------+

(mas somente se a pasta estiver vazia!)

6. Erros comuns ao criar e excluir arquivos e pastas

Erro nº 1: Tentamos criar um arquivo/pasta que já existe. Os métodos Files.createFile e Files.createDirectory lançam uma exceção se o objeto já existir. Solução — verificar a existência com antecedência ou capturar a exceção.

Erro nº 2: Tentamos criar uma pasta aninhada com createDirectory, mas a pasta pai ainda não existe. Nesse caso, ocorrerá o erro NoSuchFileException. Use createDirectories para criar a cadeia de pastas.

Erro nº 3: Tentamos excluir uma pasta não vazia com Files.delete. Você receberá DirectoryNotEmptyException. Para excluir diretórios não vazios, é necessária recursão.

Erro nº 4: Sem permissão para criar/excluir no diretório indicado. Será lançada AccessDeniedException ou IOException. Execute o programa com as permissões necessárias ou use pastas acessíveis.

Erro nº 5: Arquivo em uso por outro processo. No Windows (e às vezes em outros SOs) não é possível excluir um arquivo se ele estiver aberto em outro programa. Você receberá IOException. Feche todos os aplicativos que usam o arquivo antes de excluir.

Erro nº 6: Uso de caminhos relativos sem entender “onde você está”. O arquivo é criado em um lugar diferente do esperado. Para ter certeza, use toAbsolutePath() e imprima o caminho na tela.