1.Was ist IO?
E/A-Operationen in Java beziehen sich hauptsächlich auf die Verwendung von Java für Eingabe- und Ausgabevorgänge. Alle Java-E/A-Mechanismen basieren auf Datenströmen für die Eingabe und Ausgabe. Diese Datenströme stellen die fließende Folge von Zeichen oder Bytedaten dar. Die I/O-Streams von Java bieten Standardmethoden zum Lesen und Schreiben von Daten. Jedes Objekt in Java, das eine Datenquelle darstellt, stellt Methoden zum Lesen und Schreiben seiner Daten in einem Datenstrom bereit.
Java.io ist das Hauptpaket für die meisten datenflussorientierten Eingabe-/Ausgabeklassen. Darüber hinaus bietet Java auch Unterstützung für die Blockübertragung, und Block-E/A wird in der Kernbibliothek java.nio verwendet.
Der Vorteil von Stream IO besteht darin, dass es einfach und benutzerfreundlich ist, der Nachteil besteht jedoch darin, dass es weniger effizient ist. Block-IO ist sehr effizient, aber die Programmierung ist komplizierter.
Java IO-Modell:
Das IO-Modelldesign von Java ist sehr gut. Es verwendet das Decorator-Muster, um Streams nach Funktionen zu unterteilen. Sie können diese Streams dynamisch zusammenstellen, um die von Ihnen benötigten Funktionen zu erhalten. Wenn Sie beispielsweise einen gepufferten Dateieingabestream benötigen, sollten Sie eine Kombination aus FileInputStream und BufferedInputStream verwenden.
2. Grundkonzepte des Datenflusses
Der Datenfluss ist eine Sammlung kontinuierlicher Daten, genau wie der Wasserfluss in einer Wasserleitung. Wasser wird Stück für Stück an einem Ende der Wasserleitung zugeführt, und was am anderen Ende der Wasserleitung zu sehen ist, ist ein kontinuierlicher Fluss von Wasser. Das Datenschreibprogramm kann Daten segmentweise in die Datenflusspipeline schreiben. Diese Datensegmente bilden nacheinander einen langen Datenstrom. Bei Datenleseprogrammen ist die Segmentierung des Datenstroms beim Schreiben nicht jedes Mal erkennbar, sondern nur die vorherigen Daten können zuerst gelesen werden, und dann können die nachfolgenden Daten gelesen werden. Unabhängig davon, ob die Daten in mehreren Stapeln oder als Ganzes auf einmal geschrieben werden, ist der Effekt beim Lesen genau der gleiche.
„Ein Stream ist die Quelle oder das Ziel von Daten, die auf einer Festplatte oder einem anderen Peripheriegerät gespeichert sind.“
Es gibt drei Möglichkeiten, Daten auf einem Computer zu speichern: eine ist externer Speicher, eine ist Speicher und die andere ist Cache. Beispielsweise handelt es sich bei der Festplatte, der Magnetplatte, dem USB-Stick usw. auf dem Computer um externe Speicher. Auf dem Computer befindet sich ein Speicherstick, und der Cache befindet sich in der CPU. Der externe Speicher verfügt über die größte Speicherkapazität, gefolgt vom Speicher und schließlich dem Cache. Das Lesen von Daten aus dem externen Speicher ist jedoch am langsamsten, gefolgt vom Speicher und dem Cache. Hier finden Sie eine Zusammenfassung des Lesens von Daten vom externen Speicher in den Speicher und des Schreibens von Daten vom Speicher in den externen Speicher. Um Speicher und externen Speicher zu verstehen, können wir ihn einfach als Container verstehen, dh externer Speicher ist ein Container und Speicher ist ein anderer Container. Wie liest man also die Daten im externen Speichercontainer in den Speichercontainer und wie speichert man die Daten im Speichercontainer im externen Speicher?
In der Java-Klassenbibliothek ist der IO-Teil sehr groß, da er ein breites Spektrum an Feldern abdeckt:
Standardeingabe und -ausgabe, Dateioperationen, Datenströme im Netzwerk, Zeichenfolgenströme, Objektströme, ZIP-Dateiströme usw. In Java wird die Abstraktion von Eingabe und Ausgabe als Stream bezeichnet, der wie eine Wasserleitung ist, die zwei Container verbindet. Das Lesen von Daten aus dem externen Speicher in den Speicher wird als Eingabestream bezeichnet, und das Schreiben von Daten aus dem Speicher in den externen Speicher wird als Ausgabestream bezeichnet.
Stream ist ein sehr anschauliches Konzept. Wenn das Programm Daten lesen muss, öffnet es einen Stream zur Datenquelle. Diese Datenquelle kann eine Datei, ein Speicher oder eine Netzwerkverbindung sein. Wenn das Programm Daten schreiben muss, öffnet es in ähnlicher Weise einen Stream zum Ziel.
Die Grundkonzepte sind wie folgt zusammengefasst:
Eine geordnete Folge von Bytes mit einem Startpunkt und einem Endpunkt. Einschließlich Eingabestream und Ausgabestream.
2) Eingabestream:Das Programm liest die Datenquelle aus dem Eingabestream. Zu den Datenquellen gehört die Außenwelt (Tastatur, Dateien, Netzwerk...), die den Kommunikationskanal darstellt, der die Datenquelle in das Programm einliest
Der Zweck der Verwendung von Datenströmen besteht darin, Ausgabe und Eingabe unabhängig vom Gerät zu machen.
Input Stream ist es egal, von welchem Gerät die Datenquelle kommt (Tastatur, Datei, Netzwerk)
Dem Ausgabestream ist es egal, für welches Gerät die Daten bestimmt sind (Tastatur, Datei, Netzwerk).
3.Standard-E/A
Java-Programme können über Befehlszeilenparameter kurze Informationen mit der Außenwelt austauschen. Gleichzeitig wird festgelegt, wie Informationen mit Standard-Eingabe- und Ausgabegeräten wie Tastaturen und Monitoren ausgetauscht werden. Über Dateien können Informationen in jeglicher Datenform mit der Außenwelt ausgetauscht werden.
1. BefehlszeilenparameterLaufergebnisse:
args[0] ist <Java>
args[1] ist <C>
args[2] ist <VB>
Der Standarddatenstrom, der mit dem Java-System geliefert wird: java.lang.System:
Beachten:
(1) Die Systemklasse kann keine Objekte erstellen und kann nur ihre drei statischen Mitglieder direkt verwenden.
(2) Immer wenn die Hauptmethode ausgeführt wird, werden die oben genannten drei Objekte automatisch generiert.
1) Standardausgabestream System.out
System.out gibt Daten an das Standardausgabegerät aus und sein Datentyp ist PrintStream. Verfahren:
2)Standard-Eingabestream System.in
System.in liest Standardeingabegerätedaten (erhält Daten von der Standardeingabe, normalerweise der Tastatur) und sein Datentyp ist InputStream. Verfahren:
3)Standardfehlerstrom
System.err gibt den Standardfehler aus und sein Datentyp ist PrintStream. Detaillierte Anweisungen finden Sie in der API.
Die Standardausgabe ruft die println-Methode über System.out auf, um Parameter auszugeben und neue Zeilen umzubrechen, während die print-Methode Parameter ausgibt, aber keine neuen Zeilen umbricht. Die println- oder print-Methode implementiert mehrere Methoden zur Ausgabe grundlegender Datentypen durch Überladung, einschließlich der Ausgabeparametertypen boolean, char, int, long, float und double. Gleichzeitig werden auch Methoden überladen, deren Ausgabeparametertypen char[], String und Object sind. Unter diesen rufen die Methoden print(Object) und println(Object) zur Laufzeit die toString-Methode des Parameterobjekts auf.
öffentliche Klasse StandardInputOutput {
public static void main(String args[]) {
String s;
//Erstelle einen Pufferleser, um Daten Zeile für Zeile von der Tastatur zu lesen
InputStreamReader ir = new InputStreamReader(System.in);
BufferedReader in = new BufferedReader(ir);
System.out.println("Unix-System: Strg-D oder Strg-C zum Beenden"
+ "/nWindows-System: Strg-Z beenden");
versuchen {
//Eine Datenzeile lesen und standardmäßig auf dem Monitor ausgeben
s = in.readLine();
// Wenn beim Ausführen der readLine()-Methode ein E/A-Fehler auftritt, wird eine IOException ausgelöst.
while (s != null) {
System.out.println("Read: " + s);
s = in.readLine();
}
// Den gepufferten Reader schließen
in.close();
} Catch (IOException e) { // Alle E/A-Ausnahmen abfangen.
e.printStackTrace();
}
}
}
4.java.IO hierarchische Architektur
Die wichtigsten Dinge im gesamten Java.io-Paket sind 5 Klassen und eine Schnittstelle. Die fünf Klassen beziehen sich auf File, OutputStream, InputStream, Writer und Reader; eine Schnittstelle bezieht sich auf Serializable. Sobald Sie diese Kern-IO-Operationen beherrschen, verfügen Sie über ein erstes Verständnis des IO-Systems in Java.
Java I/O umfasst hauptsächlich die folgenden Ebenen, darunter drei Teile:
1. Der Hauptteil des Streaming-Teils IO;
2. Der Nicht-Streaming-Teil umfasst hauptsächlich einige Klassen, die den Streaming-Teil unterstützen, wie zum Beispiel: File-Klasse, RandomAccessFile-Klasse und FileDescriptor-Klasse;
3. Andere Klassen – sicherheitsbezogene Klassen im Dateileseteil, wie die SerializablePermission-Klasse, und Dateisystemklassen, die sich auf das lokale Betriebssystem beziehen, wie die FileSystem-Klasse, die Win32FileSystem-Klasse und die WinNTFileSystem-Klasse.
Die Hauptklassen sind wie folgt:
1. Datei (Dateieigenschaften und -verwaltung): Wird zur Beschreibung von Dateien oder Verzeichnissen verwendet, z. B. zum Erstellen neuer Verzeichnisse, zum Ändern von Dateinamen, zum Löschen von Dateien, zum Bestimmen des Dateipfads usw.
2. InputStream (Binärformatoperation): abstrakte Klasse, bytebasierte Eingabeoperation und ist die übergeordnete Klasse aller Eingabestreams. Definiert gemeinsame Merkmale, die alle Eingabestreams haben.
3. OutputStream (Binärformatoperation): abstrakte Klasse. Bytebasierte Ausgabeoperationen. Ist die übergeordnete Klasse aller Ausgabestreams. Definiert gemeinsame Merkmale, die alle Ausgabestreams haben.
Zeichen in Java übernehmen den Unicode-Standard. Ein Zeichen besteht aus 16 Bits, das heißt, ein Zeichen wird durch zwei Bytes dargestellt. Zu diesem Zweck wurden in JAVA Streams zur Verarbeitung von Zeichen eingeführt.
4. Reader (Dateiformatoperation): abstrakte Klasse, zeichenbasierte Eingabeoperation.
5. Writer (Dateiformatoperation): abstrakte Klasse, zeichenbasierte Ausgabeoperation.
6. RandomAccessFile (zufällige Dateioperation): Es verfügt über umfangreiche Funktionen und kann Zugriffsoperationen (Eingabe und Ausgabe) von jedem Ort in der Datei aus ausführen .
Die Architektur des IO-Streams in Java ist wie folgt:
5. Nicht-Streaming-Dateiklasse – Dateiklasse
}
Beschreibung: Methoden der File-Klasse:
(1) exist() testet, ob die angegebene Datei oder das angegebene Verzeichnis auf der Festplatte vorhanden ist
(2) mkdir () erstellt das durch das Dateiobjekt angegebene Verzeichnis (einschichtiges Verzeichnis).
(3) createNewFile() erstellt die durch das Dateiobjekt angegebene Datei
(4) list() gibt alle Dateinamenzeichenfolgen im Verzeichnis zurück
6. Java.IO-Stream-Klassenbibliothek
Das java.io-Paket enthält alle Klassen, die für Streaming-I/O benötigt werden. Es gibt vier Grundklassen im java.io-Paket: die Klassen InputStream, OutputStream, Reader und Writer, die Byteströme bzw. Zeichenströme verarbeiten:
Grundlegende Datenstrom-E/A
Eingabe/Ausgabe
Byte-Stream
Zeichenstrom
Eingabestrom
Eingabestrom
Leser
Ausgabestrom
OutputStream
Schriftsteller
Verschiedene andere Variationen von Streams in Java werden daraus abgeleitet:
In der JDK1.4-Version wurde mit der Einführung einer neuen E/A-Klassenbibliothek begonnen, die sich im Paket java.nio befindet. Die neue E/A-Klassenbibliothek verwendet Kanäle und Puffer, um die Effizienz von E/A-Vorgängen zu verbessern.
Im java.io-Paket stellt java.io.InputStream den Byte-Eingabestream und java.io.OutputStream den Byte-Ausgabestream dar, der sich auf der obersten Ebene des java.io-Pakets befindet. Beide Klassen sind abstrakte Klassen, was bedeutet, dass sie nicht instanziiert werden können und zur Erzielung bestimmter Funktionen in Unterklassen unterteilt werden müssen.
1. Spezifische Klassifizierung von IO-Flows1. Gesamtklassifizierung nach I/O-Typ:
1. Speicher 1) Lesen und Schreiben von Daten aus/in das Speicherarray: CharArrayReader, CharArrayWriter, ByteArrayInputStream, ByteArrayOutputStream
2) Lesen und Schreiben von Daten aus/in die Speicherstrings StringReader, StringWriter, StringBufferInputStream
2.Pipe-Pipeline implementiert Pipeline-Eingabe und -Ausgabe (Interprozesskommunikation): PipedReader, PipedWriter, PipedInputStream, PipedOutputStream
3.Datei-Stream . Dateien lesen und schreiben: FileReader, FileWriter, FileInputStream, FileOutputStream
4. ObjectSerialization-Objekteingabe und -ausgabe : ObjectInputStream, ObjectOutputStream
5. Der DataConversion-Datenstrom liest und schreibt gemäß den grundlegenden Datentypen (die verarbeiteten Daten sind Java-Basistypen (z. B. Boolean, Bytes, Ganzzahlen und Gleitkommazahlen)): DataInputStream, DataOutputStream
6. Das Drucken umfasst praktische Druckmethoden: PrintWriter, PrintStream
7. Beim Puffern werden Daten beim Lesen oder Schreiben zwischengespeichert, um die Anzahl der E/A zu reduzieren: BufferedReader, BufferedWriter, BufferedInputStream, BufferedOutputStream
8. Filtern des Streams , Filtern beim Lesen oder Schreiben von Daten: FilterReader, FilterWriter, FilterInputStream, FilterOutputStream passieren
9. Die Verkettung führt Eingaben zusammen und verbindet mehrere Eingabeströme zu einem Eingabestrom: SequenceInputStream
10.Counting zählt Zeilen beim Lesen von Daten: LineNumberReader, LineNumberInputStream
11.Peeking Ahead führt das Vorlesen über den Caching-Mechanismus durch: PushbackReader, PushbackInputStream
12. Durch die Konvertierung zwischen Bytes und Zeichen wird der Bytestrom gemäß bestimmten Codierungs-/Decodierungsstandards in einen Zeichenstrom konvertiert oder eine umgekehrte Konvertierung durchgeführt (Stream to Reader, Writer-Konvertierungsklasse): InputStreamReader, OutputStreamWriter
2. Klassifizierung nach Datenquelle (Ziel):
1. Datei: FileInputStream, FileOutputStream, FileReader, FileWriter
2. Byte[]: ByteArrayInputStream, ByteArrayOutputStream
3. Char[]: CharArrayReader, CharArrayWriter
4. String: StringBufferInputStream, StringReader, StringWriter
5. Netzwerkdatenstrom: InputStream, OutputStream, Reader, Writer
7. Byte-Stream InputStream/OutputStream
InputStream ist ein Byte-Eingabestream. Es ist selbst eine abstrakte Klasse und muss sich auf seine Unterklassen verlassen, um verschiedene Funktionen zu implementieren. Diese abstrakte Klasse ist die Superklasse aller Klassen, die Byte-Eingabestreams darstellen. Der von InputStream geerbte Stream gibt Daten in das Programm ein, und die Dateneinheit ist Byte (8 Bit);
InputStream ist eine Klasse, die zur Eingabe von Bytedaten verwendet wird. Daher stellt die InputStream-Klasse drei überladene Lesemethoden in der Inputstream-Klasse bereit:
(1) public abstract int read(): Liest ein Datenbyte und der Rückgabewert ist ein Wert vom Typ int, dessen hohe Bits mit 0 gefüllt sind. Wenn der Rückgabewert = -1 ist, bedeutet dies, dass keine Bytes gelesen wurden und die Lesearbeit beendet ist.
(2) public int read(byte b[]): Liest b.length-Datenbytes und fügt sie in das b-Array ein. Der Rückgabewert ist die Anzahl der gelesenen Bytes. Diese Methode wird tatsächlich durch den Aufruf der nächsten Methode (3) implementiert: public int read(byte b[ ], int off, int len): Liest bis zu len Bytes an Daten aus dem Eingabestream und speichert sie mit einem Offset von off im b-Array.
(4) public int available(): Gibt die Anzahl der Bytes zurück, die im Eingabestream gelesen werden können. Hinweis: Wenn die Eingabe blockiert ist, wird der aktuelle Thread angehalten. Wenn das InputStream-Objekt diese Methode aufruft, gibt sie nur 0 zurück. Diese Methode muss von einem Unterklassenobjekt aufgerufen werden, das die InputStream-Klasse erbt, um nützlich zu sein.
(5) public long skip(long n): Ignorieren Sie n Bytes im Eingabestream. Der Rückgabewert ist die Anzahl der tatsächlich ignorierten Bytes. Überspringen Sie einige zu lesende Bytes. (6) public int close(): Wir sind Nach der Verwendung werden die Der von uns geöffnete Stream muss geschlossen werden.
Hauptunterkategorien:
1) FileInputStream verwendet eine Datei als InputStream, um den Lesevorgang der Datei zu realisieren. 2) ByteArrayInputStream: verwendet einen Puffer im Speicher als InputStream. 3) StringBufferInputStream: verwendet ein String-Objekt als InputStream
4) PipedInputStream: Implementiert das Pipe-Konzept, das hauptsächlich in Threads verwendet wird. 5) SequenceInputStream: Führt mehrere InputStreams zu einem InputStream zusammen
Hauptunterkategorien:
1) ByteArrayOutputStream: Informationen in einem Puffer im Speicher speichern
2) FileOutputStream: Informationen in einer Datei speichern
3) PipedOutputStream: Implementiert das Pipe-Konzept, das hauptsächlich in Threads verwendet wird
4) SequenceOutputStream: Mehrere OutStreams zu einem OutStream zusammenführen
Bestimmung des Endes des Streams: wenn der Rückgabewert der Methode read() -1 ist; wenn der Rückgabewert von readLine() null ist.
3. Dateieingabestream: FileInputStream-KlasseFileInputStream kann die read()-Methode verwenden, um jeweils ein Byte zu lesen und als int-Typ zurückzugeben, oder die read()-Methode verwenden, um in ein Byte-Array einzulesen, wie viele Bytes entsprechend der Anzahl der Elemente im gelesen werden Byte-Array. Beim Lesen oder Schreiben der gesamten Datei wird ein solches Byte-Array normalerweise als Puffer verwendet, da ein solches Byte-Array normalerweise eine Zwischenrolle beim Empfang von Daten spielt.
Verwendung(2)
FileInputStream in=newFileInputStream(“d: /abc.txt“);
Programmbeispiel:
Zeigen Sie den Inhalt des Programms InputFromFile.java auf dem Monitor an
öffentliche Klasse TestFile {
public static void main(String args[]) löst eine IOException {
versuchen{
FileInputStream rf=new FileInputStream("InputFromFile.java");
int n=512; Bytepuffer[]=neues Byte[n];
while((rf.read(buffer,0,n)!=-1)&&(n>0)){
System.out.println(new String(buffer) );
}
System.out.println();
rf.close();
} Catch(IOException IOe){
System.out.println(IOe.toString());
}
}
}
Die FileOutputStream-Klasse wird zum Verarbeiten von Datenströmen verwendet, die Dateien als Datenausgabeziele verwenden; eine Zeichenfolge, die den Dateinamen darstellt, der auch ein File- oder FileDescriptor-Objekt sein kann.
Es gibt zwei Möglichkeiten, ein Dateistreamobjekt zu erstellen:
Weg 1:
Datei f=neue Datei („d:/myjava/write.txt“);
FileOutputStream out= new FileOutputStream (f);
Weg 2:
FileOutputStream out=new FileOutputStream("d:/myjava/write.txt ");
Methode 3: Der Konstruktor verwendet das FileDescriptor()-Objekt als Parameter.
FileDescriptor() fd=new FileDescriptor();
FileOutputStream f2=new FileOutputStream(fd);
Methode 4: Der Konstruktor verwendet den Dateinamen als ersten Parameter und einen booleschen Wert als zweiten Parameter.
FileOutputStream f=new FileOutputStream("d:/abc.txt",true);
Hinweis: (1) Wenn beim Schreiben von Daten in eine Datei die Datei bereits vorhanden ist, wird die vorhandene Datei überschrieben. (2) Wenn der Lese-/Schreibvorgang endet, sollte die Close-Methode aufgerufen werden, um den Stream zu schließen.
}
öffentliche Klasse TestFile {
public static void main(String args[]) löst eine IOException {
versuchen {
Datei inFile = new File("copy.java");
Datei outFile = new File("copy2.java");
FileInputStream finS = new FileInputStream(inFile);
FileOutputStream foutS = new FileOutputStream(outFile);
int c;
while ((c = finS.read()) != -1) {
foutS.write(c);
}
finS.close();
foutS.close();
} Catch (IOException e) {
System.err.println("FileStreamsTest: " + e);
}
}
}
Der Computerzugriff auf externe Geräte ist zeitaufwändig. Je häufiger auf externen Speicher zugegriffen wird, desto größer ist die Wahrscheinlichkeit, dass die CPU im Leerlauf ist. Um die Anzahl der Zugriffe auf den externen Speicher zu reduzieren, sollten bei einem Zugriff auf das Peripheriegerät mehr Daten gelesen und geschrieben werden. Zu diesem Zweck sollte zusätzlich zu den Lese- und Schreibmechanismen, die für den Datenaustausch zwischen Programmen und Flussknoten erforderlich sind, auch ein Puffermechanismus hinzugefügt werden. Gepufferter Stream bedeutet, dass jedem Datenstrom ein Puffer zugewiesen wird. Ein Puffer ist ein Speicher, in dem Daten vorübergehend gespeichert werden. Dadurch kann die Anzahl der Zugriffe auf die Festplatte reduziert und die Übertragungseffizienz verbessert werden.
BufferedInputStream: Beim Schreiben von Daten in den gepufferten Stream werden die Daten zunächst in den Puffer geschrieben. Nachdem der Puffer voll ist, sendet das System die Daten sofort an das Ausgabegerät.
BufferedOutputStream: Beim Lesen von Daten aus dem gepufferten Stream liest das System zuerst die Daten aus dem Puffer. Wenn der Puffer leer ist, liest das System die Daten dann vom Eingabegerät in den Puffer.
Verbinden Sie BufferedInputStream mit FileInputStream
FileInputStreamin=newFileInputStream( "file1.txt" );
BufferedInputStreambin=newBufferedInputStream(in);
2) Speicher in Datei schreiben:
Verbinden Sie BufferedOutputStream mit FileOutputStream
FileOutputStreamout=newFileOutputStream(“file1.txt”);
BufferedOutputStreambin=newBufferedInputStream(out);
öffentliche Klasse ReadWriteToFile {
public static void main(String args[]) löst eine IOException {
InputStreamReader sin = new InputStreamReader(System.in);
BufferedReader bin = new BufferedReader(sin);
FileWriter out = new FileWriter("myfile.txt");
BufferedWriter bout = new BufferedWriter(out);
String s;
while ((s = bin.readLine()).length() > 0) {
bout.write(s, 0, s.length());
}
}
}
8. Zeichenstrom-Schreiber/Leser
Zeichen in Java übernehmen den Unicode-Standard. Ein Zeichen besteht aus 16 Bits, das heißt, ein Zeichen wird durch zwei Bytes dargestellt. Zu diesem Zweck wurden in JAVA Streams zur Verarbeitung von Zeichen eingeführt.
Abstrakte Klasse zum Lesen von Zeichenströmen. Die einzigen Methoden, die Unterklassen implementieren müssen, sind read(char[], int, int) und close(). Die meisten Unterklassen überschreiben jedoch einige der hier definierten Methoden, um eine höhere Effizienz und/oder zusätzliche Funktionalität bereitzustellen.
1) FileReader: Entspricht FileInputStream, wird hauptsächlich zum Lesen von Zeichendateien unter Verwendung der Standardzeichenkodierung verwendet und verfügt über drei Konstruktoren:
(1) Verwenden Sie den Dateinamen als Zeichenfolge: FileReader f=new FileReader(“c:/temp.txt“);
(2) Der Konstruktor verwendet das File-Objekt als Parameter.
Datei f=neue Datei(“c:/temp.txt“);
FileReader f1=new FileReader(f);
(3) Der Konstruktor verwendet das FileDescriptor-Objekt als Parameter
FileDescriptor() fd=new FileDescriptor()
FileReader f2=new FileReader(fd);
(1) Verwenden Sie das angegebene Zeichenarray als Parameter: CharArrayReader(char[])
(2) Zeichenarray als Eingabestream verwenden: CharArrayReader(char[], int, int)
Um einen String zu lesen, lautet der Konstruktor wie folgt: public StringReader(String s);
2) CharArrayReader: entspricht ByteArrayInputStream
3) StringReader: entspricht StringBufferInputStream
4) InputStreamReader
Lesen Sie Bytes aus dem Eingabestream und konvertieren Sie sie in Zeichen: Public inputstreamReader(inputstream is);
5) FilterReader: Ermöglicht das Filtern von Zeichenströmen
protected filterReader(Reader r);
6) BufferReader: Akzeptiert ein Reader-Objekt als Parameter und fügt ihm einen Zeichenpuffer hinzu. Verwenden Sie die Methode readline(), um eine Zeile zu lesen.
Public BufferReader(Reader r);
Hauptmethoden:
(1) publicintread()throwsIOException;// Ein Zeichen lesen, der Rückgabewert ist das gelesene Zeichen
(2) publicintread(charcbuf[])throwsIOException;/*Lesen Sie eine Reihe von Zeichen in das Array cbuf[], und der Rückgabewert ist die Anzahl der tatsächlich gelesenen Zeichen*/
(3) publicabstractintread(charcbuf[],intoff,intlen)throwsIOException;
/*Längenzeichen lesen und ab dem Index des Arrays cbuf[] speichern. Der Rückgabewert ist die tatsächliche Anzahl der gelesenen Zeichen. Diese Methode muss von einer Unterklasse implementiert werden*/.
Abstrakte Klasse zum Schreiben in Zeichenströme. Die einzigen Methoden, die Unterklassen implementieren müssen, sind write(char[], int, int), Flush() und close(). Die meisten Unterklassen überschreiben jedoch einige der hier definierten Methoden, um eine höhere Effizienz und/oder zusätzliche Funktionalität bereitzustellen. Seine Unterkategorien sind wie folgt:
1) FileWrite: entspricht FileOutputStream und schreibt Zeichentypdaten unter Verwendung der Standardzeichenkodierung und Puffergröße in eine Datei.
Öffentliches FileWrite(Datei f);
2) chararrayWrite: Entspricht ByteArrayOutputStream und verwendet den Zeichenpuffer als Ausgabe.
Public CharArrayWrite();
3) PrintWrite: Formatierte Ausgabe generieren public PrintWriter(outputstream os);
4) FilterWriter: Wird zum Schreiben von Filterzeichenströmen verwendet. Protected FilterWriter(Writer w);
5) PipedWriter: entspricht PipedOutputStream
6) StringWriter: Es gibt keinen entsprechenden byteorientierten Stream
Hauptmethoden:
(1) publicvoidwrite(intc)throwsIOException; //Schreibe die unteren 16 Bits des Ganzzahlwerts c in den Ausgabestream (2) publicvoidwrite(charcbuf[])throwsIOException; //Schreibe das Zeichenarray cbuf[] in den Ausgabestream ( 3) publicabstractvoidwrite(charcbuf[],intoff,intlen) throwsIOException; //Schreibe len Zeichen ab dem Index aus im Zeichenarray cbuf[] in den Ausgabestream (4) publicvoidwrite(Stringstr)throwsIOException; //Schreibe die Zeichen hinein string str wird in den Ausgabestream geschrieben (5) publicvoidwrite(Stringstr,intoff,intlen)throwsIOException; //Len-Zeichen beginnend mit dem Index aus in string str in den Ausgabestream schreiben (6) flush() / /Ausgabestream leeren und alle gepufferten Bytes ausgeben.
(7)close() schließt den Stream publicabstractvoidclose()throwsIOException
3. Der Unterschied zwischen InputStream und Reader, der Unterschied zwischen OutputStream und Writer
public static void main(String args[]) löst eine IOException {
System.out.println("Unicode-Zeichenkodierung wird im Speicher verwendet:");
char c='gut';
int lowBit=c&0xFF; int highBit=(c&0xFF00)>>8;
System.out.println(""+lowBit+" "+highBit);
String s="OK";
System.out.println("Standard-Zeichenkodierung des lokalen Betriebssystems:");
readBuff(s.getBytes());
System.out.println("GBK-Zeichenkodierung verwenden:");
readBuff(s.getBytes("GBK"));
System.out.println("UTF-8-Zeichenkodierung:");
readBuff(s.getBytes("UTF-8") }
}
9. Unterklassen der Ausnahmeklasse IOException
1.Öffentliche Klasse EOFException:
Diese Art von Ausnahme wird ausgelöst, wenn das Ende der Datei oder des Eingabestreams ungewöhnlich erreicht wird.
2. öffentliche Klasse FileNotFoundException:
Eine Ausnahme wird ausgelöst, wenn die Datei nicht gefunden werden kann.
3. Öffentliche Klasse InterruptedIOException:
Diese Art von Ausnahme wird ausgelöst, wenn eine E/A -Operation unterbrochen wird.