BufferedReader
BufferedReader ist ein gepufferter Zeicheneingangsstrom. Es erbt vom Leser.
Der Zweck von BufferedReader besteht darin, anderen Zeicheneingangsströmen eine Pufferfunktion hinzuzufügen.
Beim Erstellen eines Bufferaders werden wir einen Leser als Parameter über seinen Konstruktor angeben. Der Bufferader liest die Daten im Leser in Stapeln und jedes Mal, wenn ein Teil davon in den Puffer gelesen wird. Nach dem Betrieb dieses Teils der Daten im Puffer wird der nächste Teil der Daten vom Leser gelesen.
Warum brauche ich Pufferung? Der Grund ist sehr einfach, Effizienzprobleme! Die Daten im Puffer werden tatsächlich im Speicher gespeichert, während die Rohdaten in Festplatten oder Nandflash gespeichert werden können. Wir wissen, dass das Lesen von Daten aus dem Speicher mindestens 10 -mal schneller ist als das Lesen von Daten von Festplatten.
Lesen Sie dann nicht einfach alle Daten gleichzeitig in den Puffer? Erstens kann es lange dauern, alle Daten zu lesen. Zweitens ist der Speicherpreis sehr teuer und die Kapazität ist nicht so groß wie die Festplatte.
Beispiel:
Import Java.io.BufferedReader; Import Java.io.BytearrayInputStream; Import Java.io.file; Import Java.io.inputStream; Import Java.io.io.fileader; Import Java.io.io.ioxception; Import Java.io.FilenotfoundExceeds -Java.ioN.Securitys -Publikumsklassifizierung; statische endgültige Int len = 5; public static void main (String [] args) {testBuffenedReader (); } / ** * BufferedReader -API -Testfunktion * / private statische void testbuffenedReader () {// Erstellen Sie einen BufferedReader -Zeichenstream, der das Array -Array -Array -Array -Array -Datei = neue Datei ("bufferedReader.txt"); BufferedReader in = new bufferedReader (New FileReader (Datei)); // 5 Zeichen aus dem Zeichenstrom lesen. "abcde" für (int i = 0; i <len; i ++) {// Wenn Sie das nächste Zeichen weiter lesen können, lesen Sie das nächste Zeichen, wenn (in.ready ()) {// lesen "nächstes Zeichen des Zeichenstroms" int tmp = in.read (); System.out.printf (" %d: %c/n", i, tmp); }} // Wenn "dieser Zeichenstrom" die Markierungsfunktion nicht unterstützt, beenden Sie direkt if (! In.marksSupported ()) {System.out.println ("Nicht unterstützt!"); zurückkehren ; } // markieren "aktuelle Indexposition", dh das Element der 6. Position - "f" // 1024 entspricht Marklimit in.mark (1024); // 22 Zeichen überspringen. in.skip (22); // 5 Zeichen Char [] buf = new char [len] lesen; in.read (buf, 0, len); System.out.printf ("buf =%s/n", String.Valueof (buf)); // Lesen Sie die verbleibenden Daten des Zeilensystems. // Setzen Sie den "Index des Eingangsstroms" auf die von Mark () gekennzeichnete Position zurück, dh auf "f" zurückgesetzt. in.reset (); // 5 Zeichen aus "Character Stream" in BUF lesen. Das heißt, lesen Sie "fghij" in.read (buf, 0, len); System.out.printf ("buf =%s/n", String.Valueof (buf)); in.close (); } catch (FilenotFoundException e) {e.printstacktrace (); } catch (SecurityException e) {e.printstacktrace (); } catch (ioException e) {e.printstacktrace (); }}} Der Inhalt von BufferedReader.txt im Programm ist wie folgt:
ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ
Auslaufergebnisse:
0: A1: B2: C3: D4: EBUF = 01234Readline = 56789BUF = fghij
Pufferliter
BufferedWriter ist ein gepufferter Zeichenausgangsstrom. Es erbt vom Schriftsteller.
Der Zweck des BufferedWriter besteht darin, anderen Charakterausgaberströmen einige Pufferfunktionen hinzuzufügen.
BufferedWriter puffert Daten über ein Charakter -Array. Wenn der Puffer voll ist oder der Benutzer die Funktion von Flush () aufruft, schreibt er die Daten des Puffer in den Ausgabestream.
Beispiel:
Import Java.io.BuffenWriter; Import Java.io.file; Import Java.io.outputStream; Import Java.io.fileWriter; Import Java.io.ioException; Import Java.io.filenotfoundException; = 5; // entspricht dem englischen Brief "AbcdefghijklMnopqrstuvwxyz" // private statische endgültige char [] arrayletters = "abcdefghijklmnopqrstuvwxyz"; Private statische Finale char [] Arrayletter = new char [] {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'}; public static void main (String [] args) {testBuffenedWriter (); } / *** BufferedWriter -API -Testfunktion* / privates statisches void testbuffenWriter () {// Erstellen Sie den gepufferten Writer, der dem "Dateiausgabe -Stream" entspricht. Seine entsprechende Puffergröße beträgt 16, dh wenn die Pufferdaten> = 16, wird der Inhalt des Puffers automatisch in den Ausgabestrom geschrieben. try {file file = new File ("bufferWriter.txt"); BufferedWriter out = new bufferedWriter (neuer FileWriter (Datei)); // Schreiben Sie die ersten 10 Zeichen des Arrayletter -Arrays in den Ausgabestream out.write (Arrayletter, 0, 10); // Schreiben Sie "Zeilenumbruch/n" in den Ausgabestream out.write ('/n'); out.flush (); // ReadUSerinput (); out.close (); } catch (FilenotFoundException e) {e.printstacktrace (); } catch (SecurityException e) {e.printstacktrace (); } catch (ioException e) {e.printstacktrace (); }} / *** Benutzereingabe lesen* / private statische void ReadUSerInput () {System.out.println ("Bitte einen Text eingeben:"); Scanner reader = neuer Scanner (System.in); // Warten Sie auf eine Eingabezeichenfolge str = reader.next (); System.out.printf ("Die Eingabe ist: %s/n", str); }}Auslaufergebnis: Die Datei "bufferWriter.txt" wird generiert und der Inhalt der Datei ist "AbcDefghij".