Java IO Bewertung

IO-Klassifizierung

Lassen Sie uns IO unter verschiedenen Gesichtspunkten klassifizieren

Klassifizierung nach E / A-Richtung

Eingabestream: lesbar

Ausgabestream: beschreibbar

Klassifizierung nach Verarbeitungseinheit

Bytestream: Die Verarbeitungseinheit ist 1 Byte (8 Bit)

char stream: Die Verarbeitungseinheit besteht aus 2 Bytes (16 Bit)

Klassifiziert nach Stufe

Low-Level-Stream: Ein- / Ausgang von bestimmten E / A-Geräten (Festplatte, Netz usw.)

High-Level-Stream: Wickeln Sie einen vorhandenen Stream und in / out

__Vorteile der Verwendung von Streams auf hoher Ebene __

1. Sie können die Operation abstrahieren und die Operationsdifferenz zur Datenquelle absorbieren.
2. Die E / A-Bedienung wird einfach
3. Verbessert die E / A-Effizienz

IO reguläre Klasse

Es gibt mehr als 40 IO-bezogene Klassen in Java, InputStream / Reader und OutputStream / Writer sind Basisklassen.

Spezifikationen für InputStream / Reader, OutputStream / Writer

InputStream/Reader

int read (): Liest eine Einheit

int read (Byte [] | char [] b): Lesen Sie b Einheiten ein

int read (Byte [] | char [] b, int off, int len): Len-Einheiten einlesen, von der Aus-Position von b speichern

OutputStream/Writer

write (int c): schreibe c

write (byte [] | char [] buf): schreibe buf

write (byte [] | char [] buf, int off, int len): Schreibe len Minuten von der Aus-Position

Regelmäßige IO-Klasse

• Möglicherweise liegt ein Tippfehler vor!

Ausprobieren

FileInputStream/FileOutputStream, FileReader/FileWriter Da es sich um einen direkten Festplattenzugriff handelt, handelt es sich um einen Stream auf niedriger Ebene.

file-input.txt

abcd1\r\n
Ah

FileInputStream (Byte-Operation)

FileInputStream

try (FileInputStream fi = new FileInputStream("./FileIOSample/file-input.txt")) {
    //4 Byte Puffer
    byte[] buff = new byte[4];

    //Anzahl der gelesenen Bytes
    int hasRead = 0;

    //Lesen Sie bis zum Buff
    while ((hasRead = fi.read(buff)) > 0) {
        
        //Konvertieren Sie das gelesene Byte in eine Zeichenfolge und geben Sie es aus
        System.out.println(new String(buff, 0, hasRead));
    }
} catch (IOException ex) {
    System.out.println(ex.getMessage());
}

Ausgabe

abcd
1
�
���
�

abcd: Erste 4-Byte-Ausgabe 1 \ r \ n.: Die erste Hälfte (1 Byte) von "A" wurde genommen, also sind die Zeichen verstümmelt! ���: Die zweite Hälfte von "A" (1 Byte) + 3 Bytes, also sind die Zeichen verstümmelt!

__ Fazit __: Erfasst jeweils die angegebenen Bytes. Bei Mehrbyte-Zeichen können die Zeichen verstümmelt sein.

FileReader (Zeichenoperation)

FileReader

try (FileReader fr = new FileReader("./FileIOSample/file-input.txt")) {
    //4 Zeichen Puffer
    char[] buff = new char[4];

    //Anzahl der gelesenen Zeichen
    int hasRead = 0;

    //Lesen Sie bis zum Buff
    while ((hasRead = fr.read(buff)) > 0) {
        
        //Konvertieren Sie das gelesene Byte in eine Zeichenfolge und geben Sie es aus
        System.out.println(new String(buff, 0, hasRead));
    }
} catch (IOException ex) {
    System.out.println(ex.getMessage());
}

Ausgabe

abcd
1
Ah
Sagen

abcd: 4-stellige Ausgabe 1 \ r \ n A: 4-Zeichen-Ausgabe Sprich: Gib die letzten 2 Zeichen aus

__ Fazit __:

1. Das angegebene Zeichen ist die Anzahl der Zeichen.
2. abcd ist 4 Bytes, aber da es 4 Zeichen sind, wird abcd ausgegeben!

FileOutputStream/FileWriter

FileInputStream

try (
    FileInputStream fi = new FileInputStream("./FileIOSample/file-input.txt")) {
    FileOutputStream fo = new FileOutputStream("./FileIOSample/file-output-1.txt");

    //4 Byte Puffer
    byte[] buff = new byte[4];

    //Anzahl der gelesenen Einheiten(Anzahl der Bytes)
    int hasRead = 0;

    while ((hasRead = fi.read(buff)) > 0) {
        //Schreiben Sie so viel wie Sie lesen
        fo.write(buff, 0, hasRead);
    }
} catch (IOException ex) {
    System.out.println(ex.getMessage());
}

try (
    FileReader fr = new FileReader("./FileIOSample/file-input.txt");
    FileWriter fo = new FileWriter("./FileIOSample/file-output-2.txt")) {
    
    //4 Zeichen Puffer
    char[] buff = new char[4];
    
    //Anzahl der gelesenen Einheiten(Anzahl der Bytes)
    int hasRead = 0;

    while ((hasRead = fr.read(buff)) > 0) {
        //Schreiben Sie so viel wie Sie lesen
        fo.write(buff, 0, hasRead);
    }
} catch (IOException ex) {
    System.out.println(ex.getMessage());
}

file-output-1.txt

abcd1
Ah

file-output-2.txt

abcd1
Ah

__ Fazit __: Sowohl Byte- als auch Zeichenoperationen können normal ausgegeben werden.

Wenn eine Zeichenfolge ausgegeben wird

FileWriter fo = new FileWriter("./FileIOSample/file-output-3.txt")) {
fo.write("Linie 1");
fo.write(System.lineSeparator());

PrintStream/PrintWrite

python

try (
    FileOutputStream fo = new FileOutputStream("./FileIOSample/file-output-4.txt");
    PrintStream ps = new PrintStream(fo)){

    ps.println(1);
    ps.println("aa");
    ps.println("AIUEO");
    ps.println(new String("a ah"));
} catch (IOException ex) {
    System.out.println(ex.getMessage());
}

try (
    FileOutputStream fo = new FileOutputStream("./FileIOSample/file-output-5.txt");
    PrintWriter ps = new PrintWriter(fo)){

    ps.println(1);
    ps.println("aa");
    ps.println("AIUEO");
    ps.println(new String("a ah"));
} catch (IOException ex) {
    System.out.println(ex.getMessage());
}

file-output-4,5.txt

1
aa
AIUEO
aaa

Zusammenfassung:

1. PrintStream / PrintWrier Es ist ein leistungsstarkes Mittel, und das häufig verwendete Systou.out ist auch PrintStream.
2. Soll ich dies für die Textausgabe verwenden?

StringReader,StringWriter

StringReader

Eingabestream mit einer Zeichenfolge als Datenquelle

StringWriter

Ausgabestream mit StringBuffer als Ausgabe

StringReader,StringWriter

String src = "AIUEO" + System.lineSeparator()
    + "abcde" + System.lineSeparator()
    + "3. Zeile";
    + 
try (StringReader sr = new StringReader(src)) {
    char[] buff = new char[4];
    int hasRead = 0;
    while ((hasRead = sr.read(buff)) > 0) {
        System.out.print(new String(buff, 0, hasRead));
    }
    System.out.println();
} catch (IOException e) {
    e.printStackTrace();
}

try (StringWriter sr = new StringWriter()) {
    sr.write("123");
    sr.write("Ah");
    System.out.println(sr.toString());
} catch (IOException e) {
    e.printStackTrace();
}

Ausgabe

AIUEO
abcde
3. Zeile
123

InputStreamReader/OutputStreamWriter InputStreamReader / OutputStreamWriter konvertiert den Byte-Stream in einen Char-Stream.

InputStreamReader,BufferedReader

try (InputStreamReader reader = new InputStreamReader(System.in);
     BufferedReader bufferedReader = new BufferedReader(reader)) {
    String line;
    System.out.print("input:");
    while ((line = bufferedReader.readLine()) != null) {
        if (line.equals("exit")) {
            System.exit(0);
        }
        System.out.println("output:" + line);
        System.out.print("input:");
    }
} catch (IOException e) {
    e.printStackTrace();
}

1. Konvertieren Sie die Standardeingabe (InputStream für System.io) in InputStreamReader
2. Konvertieren Sie InputStreamReader mit Pufferfunktion in BufferedReader
3. BufferedReader # readLine blockiert __threads, bis ein Zeilenumbruch __ gelesen wird

PushbackInputStream/PushbackReader

Ein Puffer für die Rückgabe wird vorbereitet und kann mit der folgenden Methode an den Puffer zurückgegeben werden. unread(int b) unread(byte[] | char[] buff) unread(byte[] | char[] buff, int off, int len)

1. Beim Lesen zuerst vom Push-Back-Buf.
2. Wenn die maximale Länge zum Lesen von Push-Back-Buf nicht erreicht ist, holen Sie von Buff.

push-back.txt

123456789

push-back-stream

int pushbackBuff = 8;
try (
   PushbackReader pr = new PushbackReader(new FileReader("push-back.txt"), pushbackBuff)) {
    int hasRead = 0;
    int size = 1;
    char[] buff = new char[size];

    while ( (hasRead = pr.read(buff)) != -1) {
        System.out.println(new String(buff, 0, hasRead));
        // push back
        pr.unread(buff, 0, hasRead);
        buff = new char[++size];
    }
} catch (IOException ex) {
    System.out.println();
}

Ausgabe

1
12
123
1234
12345
123456
1234567
12345678
123456789

Bild verarbeiten

1. Buff, Push-Back-Buff, Anfangsposition wird entsprechend dem Bild erzeugt

1. Read () setzt 1 in Buff aus Datei
2. Weiter ist 2
3. Wenn Sie in diesem Zustand ausgeben, wird '1' ausgegeben.

1. Setzen Sie den Buff 1 in den Push-Back-Buff

1. Mit read () gibt die erste "1" den Buff vom Push-Back-Buff ein
2. 2 gibt Buff aus der Datei ein
3. Wenn Sie in diesem Zustand ausgeben, wird '12' ausgegeben.
4. Weiter ist 3

1. Setzen Sie den Buff 12 in den Push-Back-Buff

1. Mit read () gibt 12 zuerst den Buff vom Push-Back-Buff ein.
2. 3 gibt Buff aus der Datei ein
3. Wenn Sie in diesem Zustand ausgeben, wird '123' ausgegeben.
4. Weiter ist 4

Wiederholen Sie dies! !!

ObjectInputStream/ObjectOutputStream Ein Stream zum Serialisieren und Deserialisieren von Objekten. Zum Serialisieren muss Serializable / Externalizable implementiert werden.

Modell zu verwenden

import java.io.Serializable;

public class Person implements Serializable{
    public String name;
    public int age;

    public Person(String name, int age) {
        System.out.println("Create person.");
        this.name = name;
        this.age = age;
    }
}

public class Student implements Serializable{
    public String name;
    public int age;

    public Student(String name, int age) {
        System.out.println("Create student.");
        this.name = name;
        this.age = age;
    }
}

public class Teacher implements Serializable{
    public String name;
    public int age;

    public Student student;

    public Teacher(String name, int age, Student student) {
        System.out.println("Create teacher.");
        this.name = name;
        this.age = age;
        this.student = student;
    }
}

Einzelobjekt rein / raus

Einzelobjekt in/out

System.out.println("------Serialisieren------");
try (
    //Ausgabeziel(low level stream)
    FileOutputStream fo = new FileOutputStream("object-out-1.data");
    //Objektausgabegeschichte(high level stream)
    ObjectOutputStream out = new ObjectOutputStream(fo)) {

    //Objektausgabe
    out.writeObject(new Person("alex", 30));
} catch (IOException ex) {
    System.out.println(ex.getMessage());
}

System.out.println("------Deserialisieren------");
try (
    // (low level stream)
    FileInputStream fi = new FileInputStream("object-out-1.data");
    //Objektausgabegeschichte(high level stream)
    ObjectInputStream in = new ObjectInputStream(fi)) {

    Person p = (Person) in.readObject();

    //Objektausgabe
    System.out.println(p.name);
    System.out.println(p.age);
} catch (IOException | ClassNotFoundException ex) {
    System.out.println(ex.getMessage());
}

Ausgabe

#------Serialisieren------
Create person.
#------Deserialisieren------
alex
30

Zusammenfassung:

1. Weil die Daten des Objekts serialisiert wurden, nicht die Klasse Für die Deserialisierung erforderliche Personenklasse
2. Da "Person erstellen" nicht ausgegeben wird, ist beim Deserialisieren kein Konstruktor erforderlich.

Mehrere Objekte rein / raus

//Ernst machen
out.writeObject(new Person("alex", 30));
out.writeObject(new Student("king", 20));

//Desilia Größe
Person p = (Person) in.readObject();
Student s = (Student) in.readObject();

Zusammenfassung:

1. Eine Bestellung existiert und muss in der Reihenfolge deserialisiert werden, in der sie serialisiert wurde.
2. Wenn die Reihenfolge unterschiedlich ist, wird "Ausnahme im Thread" main "java.lang.ClassCastException: io.serializable.Person kann nicht in io.serializable.Student umgewandelt werden" auftreten.

Haben Sie eine Objektreferenz

//Ernst machen
out.writeObject(new Teacher("alex", 30, new Student("king", 20)));

// writing aborted; java.io.NotSerializableException: io.serializable.Student
Teacher t = (Teacher) in.readObject();

Zusammenfassung:

1. Das referenzierte Objekt wird ebenfalls serialisiert.
2. Wenn das referenzierte Objekt Serializable nicht implementiert, wird "Schreiben abgebrochen; java.io.NotSerializableException: io.serializable.Student" ausgeführt.

Mehrere Objekte haben dieselbe Referenz

python

Student s = new Student("king", 20);
//Ernst machen
out.writeObject(new Teacher("alex", 30, s));
out.writeObject(new Teacher("bill", 40, s));

//Desilia Größe
Teacher alex = (Teacher) in.readObject();
Teacher bill = (Teacher) in.readObject();
System.out.println(alex.student == bill.student); // true

Zusammenfassung: Selbst wenn dieselbe Referenz deserialisiert wird, wird wie vor der Serialisierung nur auf ein Objekt verwiesen. Bild serialisieren:

serialVersionUID Dies soll bestätigen, dass die Klassen zum Zeitpunkt der Serialisierung und Deserialisierung identisch sind. Wenn sich Vorder- und Rückseite unterscheiden, tritt "Ausnahme im Thread" main "java.io.InvalidClassException" auf.

• Wie schreibt man
• Schreiben Sie explizit private static final long serialVersionUID = 512L;
• jvm berechnet basierend auf Klasseninformationen
• Methodenänderungen haben keine Auswirkung
• Änderungen an statischen Elementen haben keine Auswirkung
• Änderungen an nicht statischen Methoden wirken sich aus
• Kann manuell mit bin / serialver berechnet werden

Bonus

Standard-E / A-Umleitung

Java repräsentiert den Standardein- und -ausgang in System.in und System.out mit Standardtastatur und -anzeige.

• Standard-E / A-Umleitungsmethode
  • System#setErr(PrintStream err)
  • System#setIn(InputStream in)
  • System#setOut(PrintStream out)

Standardausgangsumleitung

try (FileOutputStream fileOutputStream = new FileOutputStream("strandard-output.txt");
     PrintStream print = new PrintStream(fileOutputStream)) {
    System.setOut(print);
    System.out.println("aaaaabbbbb");
} catch (IOException ex) {
    System.out.println(ex.getMessage());
}

Als nächstes kommen NIO und NIO.2.

NIO : https://qiita.com/liguofeng29/items/c827af3d62f219e17755 NIO2 : https://qiita.com/liguofeng29/items/3d0ba350a1547630727b