1. BufferedReader -Klasse
. Klassenbibliothek:
java.lang.object
java.io.reader
Java.io.BuffenedReader
. Grundkonzepte:
öffentliche Klasse BufferedReader erweitert den Leser
Lesen Sie den Text aus dem Zeicheneingangsstream und puffer individuelle Zeichen, wodurch ein effizientes Lesen von Zeichen, Arrays und Zeilen ermöglicht wird. Sie können die Größe des Puffers angeben oder die Standardgröße kann verwendet werden. In den meisten Fällen ist der Standardwert groß genug.
In der Regel führt jede von einem Leser gestellte Leseanforderung zu einer entsprechenden Leseanforderung für den zugrunde liegenden Zeichen oder den Byte -Stream. Daher wird empfohlen, alle Leser zu wickeln, deren Read () -Operationen mit BufferedReader teuer sein können (z. B. FileReader und InputStreamReader).
Der BufferedReader -Stream kann Textzeilen lesen und erstellt ein BufferedReader -Objekt, indem ein Leserobjekt an den BufferedReader weitergeleitet wird. Dies liegt daran, dass FileReader nicht die Funktion des Lesens von Textzeilen liefert.
. Demo:
Erfassen Sie die eingegebene Anweisung über den BufferedReader:
Java.io importieren. System.out.print ("Bitte geben Sie eine Reihe von Text ein, die Leerzeichen enthalten kann:"); String text = bufferedReader.readline (); System.out.println ("Bitte einen Text eingeben:"+Text); }}Anmerkung:
Wirft IoException Ausnahme aus
InputStreamReader ist die Brücke zwischen Bytefluss und Charakterfluss
2. InputStreamReader -Klasse
InputStreamReader konvertiert einen Byte -Stream in einen Zeichenstrom. Es ist die Brücke zwischen Bytefluss und Charakterfluss. Wenn nicht angegeben wird, wird der Dekodierungsprozess die Standardcharaktercodierung der Plattform verwendet, wie z. B.: GBK.
Konstruktionsmethode:
InputStreamReader ISR = New InputStreamReader (InputStream in); // Konstruktieren
InputStreamReader ISR = New InputStreamReader (InputStream in, String charSetName); // Konstruieren Sie einen angegebenen Codierungssatz
InputStreamReader -Klasse.
Der Parameter im Objekt wird durch InputStream in = System.in; // Daten auf der Tastatur lesen.
Oder InputStream in = new FileInputStream (String -Dateiname); // Lesen Sie die Daten in der Datei. Es ist ersichtlich, dass FileInputStream eine Unterklasse von InputStream ist.
Hauptmethode: int read (); // Lesen Sie ein einzelnes Zeichen.
int read (char [] cbuf); // Speichern Sie die Lesezeichen in das Array. Gibt die Anzahl der gelesenen Zeichen zurück.
. Demo:
Java.io importieren. */// Byte Stream // InputStream in = System.in; // Tastatureingabe lesen. InputStream in = new FileInputStream ("d: //demo.txt"); // Lesen Sie die Dateidaten. // Umwandlung fließender Bytes in den Zeichenstrom. Um eine effektive Konvertierung von Bytes zu Zeichen zu ermöglichen, können Sie im Voraus weitere Bytes aus dem zugrunde liegenden Stream lesen. InputStreamReader ISR = New InputStreamReader (IN); // Read // umfassend in einem Satz. // InputStreamReader isr = new InputStreamReader (// New FileInputStream ("d: //demo.txt")); char [] cha = new char [1024]; int len = isr.read (cha); System.out.println (neue String (Cha, 0, Len)); isr.close (); } public static void transReadByBuf () löst IOException { /*** Verwenden Sie Puffer, um die Methoden Read () und Readline () des Pufferobjekts zu verwenden. */// Byte -Stream // InputStream in = System.in; // Daten auf dem Tastatureingangsstream in = new FileInputStream ("d: //demo.txt"); // Daten in der Datei lesen. // Umwandlung fließender Bytes in den Zeichenstrom. InputStreamReader ISR = NEU InputStreamReader (in); // Read // Zeichen Stream Buffer BufferedReader bufr = new BufferedReader (ISR); // BUPBERD // BEBELERDREADER BUFR = New BufferedReader (// New InputStreamReader (New FileInputStream ("D: //DEMO.TXT"). kann zu einem Satz kombiniert werden. /*int ch = 0; ch = buffr.read (); System.out.println ((char) ch); */ String -Linie; while ((line = buffr.readline ())! = null) {System.out.println (Zeile); } isr.close (); }}3. Reales Fällen von InputStreamReader und BufferedReader (nicht codierter Satz)
Importieren Sie Java.io.*; Klasse utilresource {private void initializeresource () {try {// Die Datei lesen und in UTF-8-Formular BufferedReader Bufread ausschreiben; String lesen; bufread = new bufferedReader (new InputStreamReader (Resourcehelper .GetResourceInputStream ("Pinyin.txt"))); while ((read = bufread.readline ())! = null) {System.out.println (read); } bufread.close (); } catch (FilenotFoundException ex) {ex.printstacktrace (); } catch (ioException ex) {ex.printstacktrace (); }}}Hinweis: Pinyin.txt wird im Stammverzeichnis des Projekts platziert
Importieren Sie Java.io.BufferedInputStream; Import Java.io.FileInputStream; importieren Sie Java.io.FilenotFoundException; FileInputStream (Ressourcename)); } catch (FilenotFoundException e) {// Todo automatisch generierter Catch-Block e.printstacktrace (); } return null; }}Zusammenfassen:
InputStreamReader -Klasse
Es ist die Brücke zwischen Bytefluss und Zeichenfluss, die den Inputstream im Inneren umschließt. Es liest die Zeichen nacheinander in einer höheren Ebene, Eingänge/Ausgänge im Textformat und kann das Codierungsformat angeben.
BufferedReader -Klasse
BufferedReader wird von der Leserklasse erweitert, bietet eine allgemeine gepufferte Textlesung an und bietet eine sehr praktische Readline, die eine Textzeile liest, Text aus einem Charaktereingangsstrom liest und jedes Zeichen pufzt, wodurch ein effizientes Lesen von Zeichen, Arrays und Zeilen bereitgestellt wird.
PS: Die Beziehung zwischen InputStream, InputStreamReader und Leser
InputStream: Das Ergebnis ist der Byte -Eingangsstrom. Nach InputStream.read ("Dateiname") ist das Ergebnis der Byte -Stream.
Leser: Lesen eines Charakterstroms
InputStreamReader: Eine Brücke von Bytes bis hin zu Zeichen. InputStreamReader (InputStream.read ("Dateiname"));
Reader.read (InputStreamReader (InputStream in)); Kann von Byte zu Charakter geändert und gedruckt und angezeigt werden.
java.io.reader und java.io.inputstream bilden die Java -Eingangsklasse.
Der Leser wird verwendet, um 16-Bit-Zeichen zu lesen, dh unicodecodierte Zeichen; Während InputStream verwendet wird, um ASCII -Zeichen und binäre Daten zu lesen.
Der Leser unterstützt die 16-Bit-Unicode-Charakterausgabe und InputStream unterstützt die 8-Bit-Charakterausgabe.
Leser und InputStream sind zwei Sätze paralleler und unabhängiger Mechanismen der E/A -Bibliothek. 1Byte = 8Bits InputStream und OutputStream werden verwendet, um 8-Bit-Streams zu verarbeiten, und Leser und Schriftsteller werden verwendet, um 16-Bit-Streams zu verarbeiten.
In der Java-Sprache ist der Byte-Typ 8-Bit und der Zeichen-Typ 16-Bit, sodass Sie bei der Verarbeitung von Chinesen Leser und Schriftsteller verwenden müssen.
Es ist erwähnenswert, dass unter diesen beiden Ebenen von Mechanismen auch ein Bridge InputStreamReader und OutputStreamWriter vorhanden ist, der für die Anpassung von InputStream an den Leser und die Anpassung von OutputStream an den Schriftsteller verantwortlich ist.
In Java gibt es verschiedene Arten von Leser -Eingabestreams, die verschiedenen Datenquellen entsprechen:
FileReader wird zur Eingabe von einer Datei verwendet. ChararrayReader wird für die Eingabe von einem Charakter -Array im Programm verwendet. StringReader wird für die Eingabe von einer Zeichenfolge im Programm verwendet. PipeDreader wird zum Lesen von Daten verwendet, die von einem Rohrleiter in einem anderen Thread an die Pipeline geschrieben wurden.
Es gibt auch verschiedene Arten von InputStream -Eingangsströmen, die verschiedenen Datenquellen entsprechen: FileInputStream, BytearrayInputStream, StringBufferInputStream, PipeDInputStream.
Darüber hinaus gibt es zwei Eingabestream -Eingangsströme, die keinen entsprechenden Lesertyp haben: Socket wird für Steckdosen verwendet. URLConnection wird für URL -Verbindungen verwendet. Diese beiden Klassen verwenden GetInputStream (), um die Daten zu lesen.
Entsprechend gibt es ähnliche Unterschiede zwischen java.io.writer und java.io.outputstream.
In Bezug auf InputStream.read (Byte [] B) und InputStream.read (Byte [] B, int Off, Int len) beide Methoden werden verwendet, um mehrere Bytes aus einem Stream zu lesen. Erfahrene Programmierer werden feststellen, dass diese beiden Methoden die Anzahl der Bytes, die sie lesen möchten, oft nicht lesen können. Beispielsweise hoffen Programmierer bei der ersten Methode oft, dass das Programm B.Length -Bytes lesen kann, aber die tatsächliche Situation ist, dass das System oft nicht so viele lesen kann. Nachdem Sie die Anweisungen für Java -API sorgfältig gelesen haben, werden Sie feststellen, dass diese Methode nicht garantiert, dass sie so viele Bytes lesen kann. Sie kann nur garantieren, dass sie bis zu so vielen Bytes (mindestens 1) lesen kann. Wenn Sie möchten, dass das Programm Count -Bytes liest, verwenden Sie den folgenden Code am besten:
byte [] b = neues byte [count]; int ReadCount = 0; // Die Anzahl der Bytes, die erfolgreich gelesen wurden, während (ReadCount <count) {ReadCount += in.Read (Bytes, ReadCount, Count - ReadCount); } Dieser Code kann sicherstellen, dass die Zählung von Bytes gelesen wird, es sei denn, in der Mitte oder am Ende des Datenstroms (EOFException) wird eine IO -Ausnahme aufgetreten.