E aí, pessoal. Tudo certo? Hoje vamos falar sobre escrever em arquivos txt com Java extremamente objetiva e rápida.

O Java fornece várias classes para lidar com a gravação de dados em arquivos. Duas dessas classes são o BufferedWriter e o PrintWriter, que oferecem diferentes abordagens para escrever informações em um arquivo de texto. Neste artigo, vamos explorar como utilizar essas duas classes, conhecendo melhor e aprender a motivação de cada uso.

BufferedWriter

O BufferedWriter é uma classe que faz parte do pacote java.io e é utilizada para escrever caracteres em um arquivo de forma mais eficiente do que o PrintWriter, pois ele armazena temporariamente os dados em um buffer antes de escrevê-los no arquivo. Isso resulta em menos operações de escrita no disco, o que melhora o desempenho, especialmente ao escrever grandes volumes de dados.

Como criar e usar um BufferedWriter:

Para usar o BufferedWriter, você precisa criar uma instância dessa classe e associá-la a um arquivo de texto. Vejamos como fazer isso:


import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class BufferedWriterExample {
    public static void main(String[] args) {
        try (BufferedWriter writer = new BufferedWriter(new FileWriter("arquivo.txt"))) {
            writer.write("Olá, Mundo!");
            writer.newLine(); // Insere uma nova linha após o texto
            writer.write("Este é um exemplo de BufferedWriter em Java.");
						writer.close();
        } catch (IOException e) {
            System.out.println("Ocorreu um erro ao gravar o arquivo.");
        }
    }
}

Neste exemplo, criamos um BufferedWriter e associamos a ele o arquivo “arquivo.txt” usando o FileWriter. Em seguida, escrevemos duas linhas no arquivo usando o método write(), e utilizamos newLine() para inserir uma quebra de linha entre as duas linhas de texto, já o writer.close() é usado para garantir que os dados sejam gravados no arquivo. O método close() é responsável por liberar os recursos associados ao BufferedWriter e garantir que os dados sejam escritos no arquivo antes de encerrar o programa.

PrintWriter

O PrintWriter é outra classe do pacote java.io que também é usada para escrever caracteres em um arquivo. No entanto, o PrintWriter oferece funcionalidades adicionais em relação ao BufferedWriter. Ele é uma escolha mais interessante quando for usado para a gravação de dados formatados.

Como criar e usar um PrintWriter:

Vejamos como criar e usar um PrintWriter:


import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

public class PrintWriterExample {
    public static void main(String[] args) {
        try (PrintWriter writer = new PrintWriter(new FileWriter("arquivo.txt"))) {
            writer.println("Olá, Mundo!");
            writer.printf("O resultado de %d + %d é %d.", 5, 3, 5 + 3);
					  writer.close();
        } catch (IOException e) {
            System.out.println("Ocorreu um erro ao gravar o arquivo.");
        }
    }
}

Neste exemplo, criamos um PrintWriter associado ao arquivo “arquivo.txt”. Utilizamos println() para escrever uma linha de texto e printf() para escrever um texto formatado, e o writer.close() deve ser usado também para garantir que seja escrito no arquivo e para liberar os recursos antes de encerrar o programa e liberar os recursos.

Diferenças entre BufferedWriter e PrintWriter

  • BufferedWriter é mais eficiente ao gravar grandes volumes de dados devido ao uso de um buffer interno, enquanto PrintWriter pode ser mais lento devido às operações adicionais de formatação.
  • PrintWriter oferece mais métodos para lidar com saída formatada, como printf() e format(), que não estão disponíveis no BufferedWriter.
  • PrintWriter pode lidar com diferentes tipos de saída, como arquivos, saída padrão (console) e muito mais, tornando-o mais versátil em cenários diversos.

Quando usar BufferedWriter ou PrintWriter?

  • Use o BufferedWriter quando você precisar apenas escrever dados brutos de forma eficiente em um arquivo, especialmente quando lida com grandes quantidades de informações.
  • Use o PrintWriter quando precisar formatar a saída ou gravar em diferentes tipos de fluxos além de arquivos, como saída padrão (console) ou fluxos de rede.

Em resumo, o BufferedWriter é a escolha adequada para operações simples e eficientes de escrita em arquivos, enquanto o PrintWriter é mais indicado para cenários onde é necessário realizar formatação na saída ou lidar com diversos tipos de fluxos.

E lembrando, o uso dessas classes não se limita a passar valores literais, nós podemos facilmente pedir dados para o usuário e fazer isso ficar cada vez mais interessante! Exemplo:

Classe Aluno:


public class Aluno {
    String nome;
    String curso;
    String matricula;
    int idade;
    String endereco;
    String telefone;

    @Override
    public String toString() {
        return "Nome: " + nome + "\\nCurso: " + curso + "\\nMatricula: " + matricula + "\\nIdade: " + idade + "\\nEndereco: " + endereco + "\\nTelefone: " + telefone;
    }
}

Classe Main:

import javax.swing.*;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
// Import da Classe Aluno

public class Main {
    public static void main(String[] args) throws IOException {

        Aluno aluno = new Aluno();
        PrintWriter writer = new PrintWriter(new FileWriter("arquivo.txt"));

        aluno.nome = JOptionPane.showInputDialog("Digite o nome do aluno: ");
        aluno.curso = JOptionPane.showInputDialog("Digite o curso do aluno: ");
        aluno.matricula = JOptionPane.showInputDialog("Digite a matricula do aluno: ");
        aluno.idade = Integer.parseInt(JOptionPane.showInputDialog("Digite a idade do aluno: "));
        aluno.endereco = JOptionPane.showInputDialog("Digite o endereco do aluno: ");
        aluno.telefone = JOptionPane.showInputDialog("Digite o telefone do aluno: ");

        writer.print(aluno);
        writer.close();
        System.out.println(aluno);
    }
}

O programa irá fazer essas perguntas pra você e depois gravará o resultado no arquivo de texto. No meu caso, o resultado foi esse:

Arquivo.txt: Nome: Geraldo Curso: Ciência da Computação Matricula: 00000 Idade: 18 Endereco: Rua ABC, S/N Telefone: 000000000

Neste exemplo, utilizamos o método “toString()” para adicionar este valor para o PrintWriter imprimir, mas novamente, não se limita a isso. Agora, fica a seu critério usar essa funcionalidade para ajudá-lo no seu dia a dia.

Conclusão

Em suma, escrever em arquivos de texto com Java é uma tarefa simples e pode ser feita de forma eficiente usando as classes BufferedWriter e PrintWriter. O BufferedWriter é adequado para operações simples e eficientes, enquanto o PrintWriter é mais versátil e oferece mais recursos para lidar com saída formatada e diferentes tipos de fluxos. Com as possibilidades oferecidas por essas classes, é possível criar programas que interajam com o usuário e gravem informações em arquivos de texto de forma rápida e fácil. Grande abraço e até a próxima!