BufferedWriter

Program innehåller mycket ofta ett krav på att snabbt skriva data till en fil eller någon annanstans. Och detta väcker frågor: Hur ska vi göra detta? Vilken klass ska vi välja? Idag kommer vi att lära känna en lämplig kandidat för denna roll – klassen BufferedWriter .

Varför behöver vi BufferedWriter?

BufferedWriter är en klass som skriver buffrade tecken till en ström. Det låter dig minska antalet gånger du använder fysiska medier. Det vill säga, istället för att skriva ett enda tecken varje gång, skriver den data till en buffert, och skriver sedan alla tecken till mediet på en gång.

Detta ökar skrivhastigheterna avsevärt. Standardbuffertstorleken är 8192 tecken, men detta kan ändras genom att ange en ny storlek i konstruktorn:

BufferedWriter(Writer in, int sz)

Här är konstruktörens första argument en ström som kommer att ta emot den data vi skriver. Och det visar sig att sz är storleken på den nya bufferten.

Java har också en BufferedReader- klass: den används för buffrad läsning av data.

Vad är egentligen en buffert? Låt oss ta ett exempel från verkligheten. En buffert är som en korg eller kundvagn på en stormarknad. Istället för att gå fram till kassan med en enda vara, betala för den, lägga den i bagageutrymmet på din bil och sedan komma tillbaka för en annan vara, kan vi ta en kundvagn, lägga allt vi vill ha i den och sedan betala i kassan. Det är precis så en buffert fungerar: den samlar in data och tar sedan allt och skriver det, istället för att skriva varje fragment separat.

Konstruktörer och metoder för klassen BufferedWriter

Låt oss nu ta en närmare titt på BufferedWriter -klassen. Det finns två konstruktörer för att skapa ett objekt:

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

Var ute i båda konstruktörerna finns strömmen att skriva till, och sz , som redan nämnts, är storleken på bufferten.

Klassen BufferedWriter har också flera metoder. Vi ska titta närmare på några av dem idag:

Låt oss skriva ett program som kommer att skriva ett värde till en fil. FörFörfattareparameter, skickar vi enFileWritertill konstruktören. Den används för att skriva textfiler och har flera konstruktorer för att initiera objekt:

För vårt exempel använder vi en konstruktor som tar ett filnamn:

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

Vår kod kommer att använda metoden write(String str) för att skriva str till filen file.txt .

Det finns andra sätt att skriva:

• write(char[] array ) — denna variant accepterar och skriver en char array;

• write(String s, int off, int len) — denna variant tar en sträng s ; en offset off , som är index för tecknet att börja skriva från; och len , som är längden på strängen (delsträngen) som ska skrivas.

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

Den här koden kommer att skriva "Hej, Amig" till filen, eftersom vi sa åt metoden att skriva 11 tecken från index 0.

Vår kod har också ett försök med resurser :

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

Detta innebär att metoden close() anropas automatiskt på mybufferedWriterobjekt, eftersom det implementerar gränssnittet AutoCloseable .

Metoden flush() i koden används för att spola ut strömmen, vilket tvingar alla buffrade byte att skrivas. Skrivningen får inte ske utan detta anrop, eftersom det är det som indikerar att bufferten måste tömmas och att de buffrade byten måste skrivas.

Klassen BufferedWriter har också en newLine() -metod som lägger till en ny rad i vårt meddelande:

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 för metoden append() ser ut så här:

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

Den används för att lägga till csq . Här är start indexet för det första tecknet, och slutet är indexet för det sista tecknet i strängen (eller delsträngen) som ska infogas. Tecknet med indexslut infogas inte.

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

Denna kod ger dig:

Det vill säga, med append -metoden anger du vilken del av strängen som ska läggas till bufferten.

Om vi ​​tittar närmare på skillnaden mellan write() och append() ser vi först att de båda gör samma sak i princip — de skriver värden.

Skillnaden är dock att append- metoden är nyare och tar en CharSequence som argument, och eftersom String implementerar CharSequence kan vi skicka Strings and StringBuilders och StringBuffers till append- metoden. Men metoden write() accepterar bara en String .

Det var allt för nu! Idag har vi bekantat oss med buffertar, hur man utför buffrad skrivning till en fil, samt metoderna som du kan använda för att göra detta.