Die Eingangs- und Ausgangsfunktionen der Java -Sprache sind sehr leistungsfähig und flexibel, und die Eingangs- und Ausgangsvorgänge von Daten werden auf "Stream" -Sty durchgeführt. J2SDK stellt eine Vielzahl von "Stream" -Kassen bereit, um verschiedene Arten von Daten zu erhalten, die im Paket java.io definiert sind. Daten werden im Programm über Standardmethoden eingegeben oder ausgegeben.
Streams in Java können aus verschiedenen Perspektiven klassifiziert werden:
Gemäß der Richtung des Streams: Es ist in Eingabestream und Ausgangsstrom unterteilt.
Gemäß den verschiedenen Dateneinheiten: Es ist in Bytestrom (8 Bit) und Charakterstrom (16 Bit) unterteilt.
Nach verschiedenen Funktionen: In den Knotenfluss und den Verarbeitungsfluss unterteilt.
Knotenfluss: Ist ein Fluss (z. B. Datei, Speicher), der Daten aus einer bestimmten Datenquelle (Knoten) lesen und schreiben kann. Es ist wie ein einzelner Röhrchen, der mit dem Wasserhahn angeschlossen ist und Wasser freigesetzt wird.
Verarbeitungsfluss: Es ist in einem vorhandenen Stream (Knotenfluss oder Verarbeitungsfluss) "verbunden", wodurch das Programm durch Verarbeitungsdaten leistungsstärkere Lese- und Schreibfunktionen bereitgestellt wird. Genau wie auf der Grundlage eines Rohrs (Knotenfluss) werden einige dickere und spezielle Funktionsrohre (Verarbeitungsfluss) auf eine weitere Behandlung des Abflusswassers aufgenommen.
Alle von J2SDK bereitgestellten Stream -Typen, die sich im Paket Java.io befinden, erben die folgenden vier abstrakten Stream -Typen.
Die vier grundlegenden Streams InputStream, OutputStream, Reader und Writer verfügen über spezifischere Unterklassen, die in Dateiströme, Pufferströme, Datenströme, Konvertierungsströme, Druckströme, Objektströme usw. unterteilt werden, die alle spezifische Funktionen haben oder zum Betrieb spezifischer Daten verwendet werden. Unter ihnen repräsentieren dunkle Farben den Knotenfluss und helle Farben repräsentieren den Verarbeitungsfluss.
Hier fassen wir die spezifische Verwendung des Flusses durch Knotenfluss und Verarbeitungsfluss zusammen.
Klassifizierung von Knotenflüssen:
Knoten Streams Process -Datei (Datei), Array (Array im Speicher), String (String) bzw. Pipe (Pipe).
Klassifizierung der Verarbeitungsströme:
Zu den häufig verwendeten Verarbeitungsströmen gehören: Pufferstrom, Konvertierungsstrom, Datenstrom, Objektstrom und Druckstrom.
Pufferer Stream: Er muss auf dem entsprechenden Byte -Stream geseuert werden und bietet eine Pufferfunktion für Lesen und schriftliche Daten, die die Lese- und Schreibeffizienz verbessert und auch einige bequemere Methoden hinzufügen.
Die Funktion eines Pufferflusses ist wie ein Eimer. Der ursprüngliche Byte -Fluss ist ein Wasserrohr. Die Wasserleitung ist direkt mit dem Ziel verbunden. Nach dem Hinzufügen des Pufferflusses wird ein Eimer unter das Wasserrohr angeschlossen und dann in das Ziel gegossen, nachdem der Eimer mit Wasser gefüllt ist. Spielt eine Pufferrolle. Auf diese Weise können Sie mehr Daten gleichzeitig lesen, wodurch häufiges Lesen und Schreiben auf die Festplatte vermieden werden. Da es eine Pufferfunktion hat, müssen Sie beim Schreiben von Daten die Flush -Methode verwenden.
import Java.io.*; public class testbufferstream {public static void main (String [] args) {try {bufferedWriter bw = new bufferedWriter (neuer Filewriter ("f: //java/io/dat.txt"); // gepufferter Stream im Byte -Stream auf dem geschriebenen Datei BufferedReader BR = New BreperedReader (New BreperedReper (New BreperedReperedRear "(neuer Bufferedreader (New BreperedRepere" (New BreperedReader (new NewsReperedRear) (neuer Bufferedreader (New BreperedRepere "(neuer Buferreader (neuer" (New BreperedReader "(new New (newneredRepere FileReader ("f: //java//io/dat.txt")); // gepufferter Stream im Byte -Stream in der Lesedatei -Zeichenfolge s = null; für (int i = 1; i <= 100; i ++) {s = string.valueof (math.random ()); // Zuweisen S BW.Write (s); // Schreiben Sie S in Dat.txt -Datei bw.newline (); // Schreiben Sie einen Zeilenunterbrechungscharakter. Eine bessere Möglichkeit, gepufferte Streams zu verwenden, besteht darin, eine Reihe von Daten zu schreiben oder zu lesen. } bw.flush (); // Machen Sie alle Daten im Speicher sofort ausgeschrieben und nicht mehr gepuffert. while ((s = br.readline ())! } bw.close (); // Schließen Sie den Verarbeitungsfluss und schließen Sie den Knotenfluss im Inneren. Br.CLOSE (); } catch (ioException e) {e.printstacktrace (); }}} Umfluss konvertieren: Verwenden Sie die Konvertierung mit Byte -Daten zu Zeichendaten. Der InputStreamReader benötigt eine InputStream -Socket, und der Ausgangsstreamwriter benötigt eine Ausgangsstream -Sockel.
Datenfluss: DataNputStream und DataOutputStream geben das Schreiben oder Lesen des Basistyps in eine Datei an. Dieser Stream ist von großem Nutzen. Wenn es keinen solchen Strom gibt, gibt es eine lange, die nur 8 Bytes aufnimmt. Wenn ich in die Datei schreiben möchte, muss ich sie in eine Zeichenfolge konvertieren und dann in ein Charakter -Array umwandeln, der Speicherplatz nimmt viel auf. Mit diesem Strom ist es jedoch sehr bequem. Schreiben Sie diese 8 Bytes einfach in die Datei, die nicht nur Speicherplatz spart, sondern das Programm auch bequemer und einfacher macht. Sie müssen jedoch beim Lesen aufpassen. Entsprechend der Art der von Ihnen gelesenen Daten wird der Zeiger nach unten bewegt, sodass die von Ihnen gelesene Reihenfolge mit der Reihenfolge des Schreibens übereinstimmen muss, um Ihre korrekten Anforderungen zu erfüllen. Andernfalls entspricht es der Aufteilung der Daten.
import Java.io.*; public class testDatastream {public static void main (String [] args) {bytearrayoutputStream baos = new bytearrayoutputStream (); // Erstellen Sie einen Knotenfluss. DataOutputStream dos = neuer DataOutputStream (BAOS); // einen Datenstrom "Pipe" an den Knotenstream anschließen {dos.writedouble (math.random ()); // Doppeltyp, 8 Bytes dos.writeBoolean (true); // booleschen Typ, nimmt einen bytebytearrayinputstream bais = new bytearrayinputstream (baos.tobytearray ()) ein; System.out.println (bais.available ()); // Gesamtzahl der verfügbaren Bytes im Ausgabestream-9 DataNputStream dis = new DataNputStream (BAIS); // Verbinden Sie auch den Datenstrom "Pipe" außerhalb des Ausgabestreams System.out.println (dis.readDouble ()); // Lesen Sie das Doppel -Typ -Nummer system.out.println (dis.readboolean ()) vor; // Lesen Sie den booleschen Typ dos.close () vor; dis.close (); } catch (ioException e) {e.printstacktrace (); }}}
Druckstream: Java.io bietet Streams zum Drucken. Diese Art von Stream hat die Funktion, beim Schreiben automatisch zu spülen, sodass jedes Mal, wenn Sie etwas drucken, spülen müssen.
import Java.io.*; public class testprintstream1 {public static void main (String [] args) {printstream ps = null; Try {FileOutputStream fos = new FileOutputStream ("f: //java//io/log.dat"); // Erstellen Sie den Ausgabestream und geben Sie den Ausgabestandort ps = new printstream (fos) an; // Packen Sie den Druckstream außerhalb des Streams} catch (ioException e) {e.printstacktrace (); } if (ps! = null) {System.SETOut (ps); // Setzen Sie den Druck des Systems, um Stream PS} int ln = 0 zu drucken; für (char c = 0; c <= 60000; c ++) {System.out.print (c+""); // Nicht in das DOS -Fenster drucken, der Ausgabestream wird direkt in die angegebene Datei gedruckt if (ln ++> = 100) {System.out.println (); ln = 0; }}}}