BufferedWriter

Programmer indeholder meget ofte et krav om hurtigt at skrive data til en fil eller andre steder. Og det rejser spørgsmål: Hvordan skal vi gøre det? Hvilken klasse skal vi vælge? I dag lærer vi en passende kandidat til denne rolle at kende - BufferedWriter- klassen.

Hvorfor har vi brug for BufferedWriter?

BufferedWriter er en klasse, der skriver bufrede tegn til en stream. Det giver dig mulighed for at reducere antallet af gange, du får adgang til fysiske medier. Det vil sige, at i stedet for at skrive et enkelt tegn hver gang, skriver den data til en buffer og skriver derefter alle tegnene til mediet på én gang.

Dette øger skrivehastigheden markant. Standardbufferstørrelsen er 8192 tegn, men dette kan ændres ved at angive en ny størrelse i konstruktøren:

BufferedWriter(Writer in, int sz)

Her er konstruktørens første argument en strøm, der vil modtage de data, vi skriver. Og det viser sig, at sz er størrelsen på den nye buffer.

Java har også en BufferedReader- klasse: den bruges til bufferlæsning af data.

Hvad er en buffer egentlig? Lad os tage et eksempel fra det virkelige liv. En buffer er som en kurv eller indkøbskurv i et supermarked. I stedet for at gå hen til kassen med en enkelt vare, betale for den, lægge den i bagagerummet på din bil og så vende tilbage efter en anden vare, kan vi tage en indkøbskurv, lægge alt, hvad vi vil have i den, og så betale ved kassen. Det er præcis sådan en buffer fungerer: den indsamler data og tager så alt og skriver det, i stedet for at skrive hvert fragment separat.

Konstruktører og metoder i BufferedWriter-klassen

Lad os nu se nærmere på BufferedWriter -klassen. Der er to konstruktører til at skabe et objekt:

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

Hvor ude i begge konstruktører er strømmen, der skal skrives til, og sz er, som allerede nævnt, størrelsen af ​​bufferen.

BufferedWriter - klassen har også flere metoder. Vi vil se nærmere på nogle af dem i dag:

Lad os skrive et program, der vil skrive en værdi til en fil. ForForfatterparameter, sender vi enFileWritertil konstruktøren. Det bruges til at skrive tekstfiler og har flere konstruktører til at initialisere objekter:

For vores eksempel bruger vi en konstruktør, der tager et filnavn:

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

Vores kode vil bruge metoden write(String str) til at skrive str til filen file.txt .

Der er andre metoder til at skrive:

• write(char[] array ) — denne variant accepterer og skriver en char array;

• skriv(String s, int off, int len) — denne variant tager en streng s ; en offset off , som er et indeks for det tegn, man skal begynde at skrive fra; og len , som er længden af ​​den streng (understreng), der skal skrives.

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

Denne kode vil skrive "Hej, Amig" til filen, da vi fortalte metoden at skrive 11 tegn fra indeks 0.

Vores kode har også en prøve-med-ressourceblok :

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

Det betyder, at close() metoden kaldes automatisk på minbufferedWriterobjekt, fordi det implementerer den AutoCloseable- grænseflade.

Flush () -metoden i koden bruges til at tømme outputstrømmen, hvilket tvinger alle bufferede bytes til at blive skrevet. Skrivningen kan ikke forekomme uden dette kald, da det er det, der indikerer, at bufferen skal tømmes, og at de bufferede bytes skal skrives.

BufferedWriter - klassen har også en newLine() -metode, der tilføjer en ny linje til vores besked:

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

I filen får vi:

Signaturen for append() -metoden ser sådan ud:

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

Det bruges til at tilføje csq . Her er start indekset for det første tegn, og slut er indekset for det sidste tegn i strengen (eller understrengen), der skal indsættes. Tegnet med indeksslutning er ikke indsat.

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

Denne kode vil give dig:

Det vil sige, med append- metoden angiver du hvilken del af strengen, der skal tilføjes til bufferen.

Ser vi nærmere på forskellen mellem write() og append() , ser vi først, at de begge gør det samme i princippet - de skriver værdier.

Forskellen er dog, at append- metoden er nyere og tager en CharSequence som argument, og fordi String implementerer CharSequence , kan vi videregive Strings og StringBuilders og StringBuffers til append- metoden. Men metoden write() accepterer kun en streng .

Det var det for nu! I dag har vi stiftet bekendtskab med buffere, hvordan man udfører bufferskrivning til en fil, samt de metoder, du kan bruge til at gøre dette.