BufferedWriter

Programma's bevatten vaak een vereiste om snel gegevens naar een bestand of ergens anders te schrijven. En dat roept vragen op: hoe moeten we dat doen? Welke klasse moeten we kiezen? Vandaag maken we kennis met een geschikte kandidaat voor deze rol: de klasse BufferedWriter .

Waarom hebben we BufferedWriter nodig?

BufferedWriter is een klasse die gebufferde karakters naar een stream schrijft. Hiermee kunt u het aantal keren dat u toegang krijgt tot fysieke media verminderen. Dat wil zeggen, in plaats van elke keer een enkel teken te schrijven, schrijft het gegevens naar een buffer en schrijft vervolgens alle tekens in één keer naar het medium.

Dit verhoogt de schrijfsnelheid enorm. De standaard buffergrootte is 8192 tekens, maar dit kan worden gewijzigd door een nieuwe grootte op te geven in de constructor:

BufferedWriter(Writer in, int sz)

Hier is het eerste argument van de constructor een stream die de gegevens die we schrijven zal ontvangen. En het blijkt dat sz de grootte is van de nieuwe buffer.

Java heeft ook een klasse BufferedReader : deze wordt gebruikt voor het gebufferd lezen van gegevens.

Wat is een buffer precies? Laten we een realistisch voorbeeld nemen. Een buffer is als een mandje of winkelwagentje bij een supermarkt. In plaats van naar de kassa te lopen met een enkel item, ervoor te betalen, het in de kofferbak van je auto te stoppen en dan terug te komen voor een ander item, kunnen we een winkelwagentje nemen, alles erin stoppen wat we willen en dan betalen bij de kassa. Dit is precies hoe een buffer werkt: het verzamelt gegevens en neemt dan alles en schrijft het, in plaats van elk fragment afzonderlijk te schrijven.

Constructors en methoden van de klasse BufferedWriter

Laten we nu de klasse BufferedWriter eens nader bekijken . Er zijn twee constructors voor het maken van een object:

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

Waar in beide constructors de stream is waarnaar moet worden geschreven, en sz , zoals eerder vermeld, is de grootte van de buffer.

De klasse BufferedWriter heeft ook verschillende methoden. We zullen er vandaag een aantal nader bekijken:

Laten we een programma schrijven dat een waarde naar een bestand zal schrijven. Voor deauteurparameter, we geven aFileWriteraan de constructeur. Het wordt gebruikt om tekstbestanden te schrijven en heeft verschillende constructors om objecten te initialiseren:

Voor ons voorbeeld gebruiken we een constructor die een bestandsnaam aanneemt:

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());
 }

Onze code gebruikt de methode write(String str) om str naar het bestand file.txt te schrijven .

Er zijn andere manieren om te schrijven:

• write(char[] array ) — deze variant accepteert en schrijft een char- array;

• write(String s, int off, int len) — deze variant neemt een string s ; een offset off , wat de index is van het teken om te beginnen met schrijven; en len , wat de lengte is van de string (substring) die moet worden geschreven.

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());
}

Deze code zal "Hallo, Amig" naar het bestand schrijven, aangezien we de methode hebben verteld om 11 tekens te schrijven vanaf index 0.

Onze code heeft ook een try-with resources- blok:

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

Dit betekent dat de methode close() automatisch wordt aangeroepen op mygebufferdeWriterobject, omdat het de AutoCloseable- interface implementeert.

De methode flush() in de code wordt gebruikt om de uitvoerstroom te spoelen, waardoor alle gebufferde bytes moeten worden geschreven. Het schrijven kan niet plaatsvinden zonder deze aanroep, omdat dit aangeeft dat de buffer moet worden geleegd en dat de gebufferde bytes moeten worden geschreven.

De klasse BufferedWriter heeft ook een methode newLine() die een nieuwe regel toevoegt aan ons bericht:

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());
    }

In het bestand krijgen we:

De handtekening van de methode append() ziet er als volgt uit:

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

Het wordt gebruikt om csq toe te voegen . Hier is start de index van het eerste teken en einde is de index van het laatste teken van de string (of substring) die moet worden ingevoegd. Het teken met indexeinde wordt niet ingevoegd.

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());
}

Deze code geeft je:

Dat wil zeggen, met de append- methode specificeert u welk deel van de tekenreeks aan de buffer moet worden toegevoegd.

Als we het verschil tussen write() en append() nader bekijken , zien we eerst dat ze allebei in principe hetzelfde doen: ze schrijven waarden.

Het verschil is echter dat de append- methode nieuwer is en een CharSequence als argument gebruikt, en omdat String CharSequence implementeert , kunnen we Strings en StringBuilders en StringBuffers doorgeven aan de append- methode. Maar de methode write() accepteert alleen een String .

Dat is het voor nu! Vandaag hebben we kennis gemaakt met buffers, hoe u gebufferd naar een bestand kunt schrijven, evenals de methoden die u hiervoor kunt gebruiken.