BufferedWriter

Programele includ foarte adesea o cerință de a scrie rapid date într-un fișier sau în altă parte. Și asta ridică întrebări: cum ar trebui să facem asta? Ce clasa ar trebui sa alegem? Astăzi vom face cunoștință cu un candidat potrivit pentru acest rol - clasa BufferedWriter .

De ce avem nevoie de BufferedWriter?

BufferedWriter este o clasă care scrie caractere în buffer într-un flux. Vă permite să reduceți numărul de accesări media fizice. Adică, în loc să scrie un singur caracter de fiecare dată, scrie date într-un buffer și apoi scrie toate caracterele pe mediu deodată.

Acest lucru mărește foarte mult viteza de scriere. Dimensiunea implicită a tamponului este de 8192 de caractere, dar aceasta poate fi modificată prin specificarea unei noi dimensiuni în constructor:

BufferedWriter(Writer in, int sz)

Aici, primul argument al constructorului este un flux care va primi datele pe care le scriem. Și se dovedește că sz este dimensiunea noului buffer.

Java are, de asemenea, o clasă BufferedReader : este folosită pentru citirea în tampon a datelor.

Ce este mai exact un buffer? Să luăm un exemplu de viață reală. Un tampon este ca un coș sau un coș de cumpărături într-un supermarket. În loc să mergem la casă cu un singur articol, să plătim pentru el, să-l punem în portbagajul mașinii și apoi să ne întoarcem pentru un alt articol, putem lua un coș de cumpărături, punem tot ce ne dorim în el și apoi plătim. la casă. Exact așa funcționează un buffer: colectează date și apoi ia totul și îl scrie, în loc să scrie fiecare fragment separat.

Constructori și metode ale clasei BufferedWriter

Acum să aruncăm o privire mai atentă la clasa BufferedWriter . Există doi constructori pentru crearea unui obiect:

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

Unde în ambii constructori este fluxul în care să scrieți, iar sz , așa cum sa menționat deja, este dimensiunea bufferului.

Clasa BufferedWriter are, de asemenea, mai multe metode. Vom arunca o privire mai atentă la unele dintre ele astăzi:

Să scriem un program care va scrie o valoare într-un fișier. PentruScriitorparametrul, vom trece unFileWritercătre constructor. Este folosit pentru a scrie fișiere text și are mai mulți constructori pentru a inițializa obiecte:

Pentru exemplul nostru, vom folosi un constructor care ia un nume de fișier:

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

Codul nostru va folosi metoda write(String str) pentru a scrie str în fișierul file.txt .

Există și alte metode de scriere:

• write(char[] array ) — această variantă acceptă și scrie o matrice char ;

• write(String s, int off, int len) — această variantă ia un șir s ; un offset off , care este indexul caracterului din care începe să scrieți; și len , care este lungimea șirului (subșirului) de scris.

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

Acest cod va scrie „Bună ziua, Amig” în fișier, deoarece am spus metodei să scrie 11 caractere începând de la indexul 0.

Codul nostru are și un bloc de resurse de încercare :

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

Aceasta înseamnă că metoda close() este apelată automat pe mybufferedWriterobiect, deoarece implementează interfața AutoCloseable .

Metoda flush() din cod este folosită pentru a șterge fluxul de ieșire, forțând toți octeții din buffer să fie scriere. Scrierea poate să nu aibă loc fără acest apel, deoarece este ceea ce indică faptul că tamponul trebuie golit și că octeții tamponați trebuie să fie scrieți.

Clasa BufferedWriter are și o metodă newLine() care adaugă o nouă linie la mesajul nostru:

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

În fișier, obținem:

Semnătura metodei append() arată astfel:

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

Este folosit pentru a adăuga csq . Aici start este indexul primului caracter, iar sfârşitul este indexul ultimului caracter al şirului (sau subşirului) de inserat. Caracterul cu sfârșitul indexului nu este inserat.

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

Acest cod vă va oferi:

Adică, cu metoda append , specificați ce parte a șirului să adăugați în buffer.

Privind mai atent diferența dintre write() și append() , vedem mai întâi că ambele fac același lucru în principiu - scriu valori.

Totuși, diferența este că metoda append este mai nouă și ia un CharSequence ca argument și, deoarece String implementează CharSequence , putem trece Strings și StringBuilders și StringBuffers la metoda append . Dar metoda write() va accepta doar un String .

Atât deocamdată! Astăzi ne-am familiarizat cu bufferele, cum să efectuați scrierea tamponată într-un fișier, precum și metodele pe care le puteți utiliza pentru a face acest lucru.