BufferedWriter

Os programas geralmente incluem um requisito para gravar dados rapidamente em um arquivo ou em outro lugar. E isso levanta questões: como devemos fazer isso? Qual classe devemos escolher? Hoje conheceremos um candidato adequado para essa função — a classe BufferedWriter .

Por que precisamos do BufferedWriter?

BufferedWriter é uma classe que grava caracteres em buffer em um fluxo. Ele permite reduzir o número de vezes que você acessa a mídia física. Ou seja, em vez de escrever um único caractere a cada vez, ele grava os dados em um buffer e, em seguida, grava todos os caracteres na mídia de uma vez.

Isso aumenta muito as velocidades de gravação. O tamanho do buffer padrão é de 8192 caracteres, mas isso pode ser alterado especificando um novo tamanho no construtor:

BufferedWriter(Writer in, int sz)

Aqui, o primeiro argumento do construtor é um stream que receberá os dados que escrevemos. Acontece que sz é o tamanho do novo buffer.

Java também tem uma classe BufferedReader : ela é usada para leitura de dados em buffer.

O que exatamente é um buffer? Vamos dar um exemplo da vida real. Um buffer é como uma cesta ou carrinho de compras em um supermercado. Em vez de ir até o caixa com um único item, pagar por ele, colocá-lo no porta-malas do carro e depois voltar para pegar outro item, podemos pegar um carrinho de compras, colocar tudo o que queremos nele e depois pagar no caixa. É exatamente assim que um buffer funciona: ele coleta dados e depois pega tudo e os grava, em vez de gravar cada fragmento separadamente.

Construtores e métodos da classe BufferedWriter

Agora vamos dar uma olhada mais de perto na classe BufferedWriter . Existem dois construtores para criar um objeto:

public BufferedWriter(Writer out) 
public BufferedWriter(Writer out, int sz)

Onde out em ambos os construtores é o fluxo no qual gravar e sz , como já mencionado, é o tamanho do buffer.

A classe BufferedWriter também possui vários métodos. Vamos dar uma olhada em alguns deles hoje:

Vamos escrever um programa que escreverá um valor em um arquivo. Para oEscritorparâmetro, vamos passar umFileWriterao construtor. Ele é usado para escrever arquivos de texto e possui vários construtores para inicializar objetos:

Para nosso exemplo, usaremos um construtor que recebe um nome de arquivo:

try(BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("file.txt"))){
	
	String message = "Hello, Amigo! This is a very important message!";
	bufferedWriter.write(message);
	bufferedWritter.flush();
}
catch(IOException ex){
System.out.println(ex.getMessage());
 }

Nosso código usará o método write(String str) para gravar str no arquivo file.txt .

Existem outros métodos para escrever:

• write(char[] array ) — esta variante aceita e escreve um array char ;

• write(String s, int off, int len) — esta variante recebe uma string s ; um offset off , que é o índice do caractere a partir do qual começar a escrever; e len , que é o comprimento da string (substring) a ser escrita.

try(BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("file.txt"))){
	String message = "Hello, Amigo! This is a very important message!";
	bufferedWriter.write(message, 0, 11);
 	bufferedWriter.flush();

} catch(IOException ex) {
System.out.println(ex.getMessage());
}

Este código irá escrever "Hello, Amig" no arquivo, já que dissemos ao método para escrever 11 caracteres a partir do índice 0.

Nosso código também possui um bloco try-with resources :

try(BufferedWriter bufferedWritter = new BufferedWriter(new FileWriter("file.txt"))) 

Isso significa que o método close() é chamado automaticamente no meubufferedWriterobjeto, porque implementa a interface AutoCloseable .

O método flush() no código é usado para liberar o fluxo de saída, forçando a gravação de todos os bytes armazenados em buffer. A escrita pode não ocorrer sem esta chamada, pois é ela que indica que o buffer deve ser descarregado e que os bytes do buffer devem ser escritos.

A classe BufferedWriter também possui um método newLine() que adiciona uma nova linha à nossa mensagem:

try (BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("file.txt"))) {
        String message = "Hello, Amigo! This is a very important message!";
        bufferedWriter.write(message, 0, 13);
        bufferedWriter.newLine();
        bufferedWriter.write(message, 15, 33);
    } catch (IOException ex) {
        System.out.println(ex.getMessage());
    }

No arquivo, obtemos:

A assinatura do método append() fica assim:

public Writer append(CharSequence csq, int start, int end)

É usado para adicionar csq . Aqui start é o índice do primeiro caractere e end é o índice do último caractere da string (ou substring) a ser inserida. O caractere com final de índice não é inserido.

try (BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("file.txt"))) {
    String message = "Hello, Amigo! This is a very important message!";
    bufferedWriter.append(message, 0, 7);
    bufferedWriter.flush();
} catch (IOException ex) {
    System.out.println(ex.getMessage());
}

Este código vai te dar:

Ou seja, com o método append , você especifica qual parte da string adicionar ao buffer.

Observando mais de perto a diferença entre write() e append() , primeiro vemos que ambos fazem a mesma coisa em princípio — eles escrevem valores.

No entanto, a diferença é que o método append é mais novo e usa um CharSequence como argumento e, como String implementa CharSequence , podemos passar Strings e StringBuilders e StringBuffers para o método append . Mas o método write() aceitará apenas uma String .

Por enquanto é isso! Hoje nos familiarizamos com os buffers, como executar a gravação em buffer em um arquivo, bem como os métodos que você pode usar para fazer isso.