java IO examen

Classification IO

Classifions les E / S de plusieurs points de vue

Classification par direction IO

flux d'entrée: lisible

flux de sortie: inscriptible

Classification par unité de traitement

flux d'octets: l'unité de traitement est de 1 octet (8 bits)

char stream: l'unité de traitement est de 2 octets (16 bits)

Classé par niveau

flux bas niveau: entrée / sortie d'un équipement IO spécifique (disque dur, réseau, etc.)

flux de haut niveau: enveloppe un flux existant et entrée / sortie

__Avantages de l'utilisation d'un flux de haut niveau __

1. Vous pouvez résumer l'opération et absorber la différence d'opération dans la source de données.
2. L'opération IO devient facile
3. Améliore l'efficacité des E / S

Cours régulier IO

Il existe plus de 40 classes liées aux E / S en java, InputStream / Reader et OutputStream / Writer sont toutes des classes de base.

Spécifications InputStream / Reader, OutputStream / Writer

InputStream/Reader

int read (): Lire une unité

int read (byte [] | char [] b): Lire en b unités

int read (byte [] | char [] b, int off, int len): Lire en unités len, stocker à partir de la position off de b

OutputStream/Writer

écriture (int c): écriture c

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

write (byte [] | char [] buf, int off, int len): Ecrit len minutes à partir de la position off

Classe IO régulière

• Il peut y avoir une faute de frappe!

Essaie

FileInputStream/FileOutputStream, FileReader/FileWriter Puisqu'il s'agit d'un accès direct au disque, il s'agit d'un flux de bas niveau.

file-input.txt

abcd1\r\n
Ah

FileInputStream (opération sur octets)

FileInputStream

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

    //Nombre d'octets lus
    int hasRead = 0;

    //Lire jusqu'à buff
    while ((hasRead = fi.read(buff)) > 0) {
        
        //Convertit l'octet lu en chaîne de caractères et produit
        System.out.println(new String(buff, 0, hasRead));
    }
} catch (IOException ex) {
    System.out.println(ex.getMessage());
}

production

abcd
1
�
���
�

abcd: première sortie 4 octets 1 \ r \ n .: La première moitié (1 octet) de "A" a été prise, les caractères sont donc déformés! ���: La seconde moitié de "A" (1 octet) + 3 octets, donc les caractères sont brouillés!

__ Conclusion __: acquiert les octets spécifiés à la fois, et dans le cas de caractères multi-octets, les caractères peuvent être déformés.

FileReader (opération char)

FileReader

try (FileReader fr = new FileReader("./FileIOSample/file-input.txt")) {
    //Tampon 4 caractères
    char[] buff = new char[4];

    //Nombre de caractères lus
    int hasRead = 0;

    //Lire jusqu'à buff
    while ((hasRead = fr.read(buff)) > 0) {
        
        //Convertit l'octet lu en chaîne de caractères et produit
        System.out.println(new String(buff, 0, hasRead));
    }
} catch (IOException ex) {
    System.out.println(ex.getMessage());
}

production

abcd
1
Ah
Dire

abcd: sortie à 4 caractères 1 \ r \ n A: sortie 4 caractères Dites: affichez les 2 derniers caractères

__Conclusion __:

1. Le caractère spécifié est le nombre de caractères.
2. abcd est de 4 octets, mais comme il est de 4 caractères, abcd est affiché!

FileOutputStream/FileWriter

FileInputStream

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

    //Tampon de 4 octets
    byte[] buff = new byte[4];

    //Nombre d'unités lues(Nombre d'octets)
    int hasRead = 0;

    while ((hasRead = fi.read(buff)) > 0) {
        //Écrivez autant que vous lisez
        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")) {
    
    //Tampon 4 caractères
    char[] buff = new char[4];
    
    //Nombre d'unités lues(Nombre d'octets)
    int hasRead = 0;

    while ((hasRead = fr.read(buff)) > 0) {
        //Écrivez autant que vous lisez
        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

__ Conclusion __: Les opérations d'octet et de caractère peuvent être générées normalement.

Lorsqu'une chaîne de caractères est sortie

FileWriter fo = new FileWriter("./FileIOSample/file-output-3.txt")) {
fo.write("Ligne 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

Résumé:

1. PrintStream / PrintWrier C'est un moyen puissant, et le Systou.out fréquemment utilisé est également PrintStream.
2. Dois-je l'utiliser pour la sortie de texte?

StringReader,StringWriter

StringReader

flux d'entrée avec une chaîne de caractères comme source de données

StringWriter

flux de sortie avec StringBuffer comme sortie

StringReader,StringWriter

String src = "AIUEO" + System.lineSeparator()
    + "abcde" + System.lineSeparator()
    + "3e ligne";
    + 
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();
}

production

AIUEO
abcde
3e ligne
123

InputStreamReader/OutputStreamWriter InputStreamReader / OutputStreamWriter convertit le flux d'octets en flux de caractères.

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. Convertissez l'entrée standard (InputStream pour System.io) en InputStreamReader
2. Convertissez InputStreamReader en BufferedReader avec la fonction de tampon
3. BufferedReader # readLine bloque __threads jusqu'à ce qu'il lit un saut de ligne __

PushbackInputStream/PushbackReader

Un tampon pour le retour est préparé et il peut être retourné au tampon par la méthode suivante. unread(int b) unread(byte[] | char[] buff) unread(byte[] | char[] buff, int off, int len)

1. Lors de la lecture, obtenez d'abord de push-back-buf.
2. Si la longueur maximale à lire depuis push-back-buf n'est pas atteinte, récupérez-la auprès de 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();
}

production

1
12
123
1234
12345
123456
1234567
12345678
123456789

Traitement de l'image

1. buff, push-back-buff, la position initiale est générée en fonction de l'image

1. Read () met «1» dans buff à partir du fichier
2. Le suivant est 2
3. Si vous sortez dans cet état, «1» est émis.

1. Mettez le buff 1 dans push-back-buff

1. Avec read (), le premier «1» entre dans le buff de push-back-buff
2. «2» entre buff à partir du fichier
3. Si vous sortez dans cet état, «12» est émis.
4. Le suivant est 3

1. Mettez le buff 12 dans push-back-buff

1. Avec read (), «12» entre en premier dans le buff de push-back-buff.
2. 3 entre buff à partir du fichier
3. Si vous sortez dans cet état, «123» est émis.
4. Le suivant est 4

Répétez ceci! !!

ObjectInputStream/ObjectOutputStream Un flux pour la sérialisation et la désérialisation d'objets. Afin de sérialiser, il est nécessaire d'implémenter Serializable / Externalizable.

Modèle à utiliser

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;
    }
}

Objet unique entrant / sortant

Objet unique dans/out

System.out.println("------Sérialiser------");
try (
    //Destination de sortie(low level stream)
    FileOutputStream fo = new FileOutputStream("object-out-1.data");
    //Histoire de sortie d'objet(high level stream)
    ObjectOutputStream out = new ObjectOutputStream(fo)) {

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

System.out.println("------Désérialiser------");
try (
    // (low level stream)
    FileInputStream fi = new FileInputStream("object-out-1.data");
    //Histoire de sortie d'objet(high level stream)
    ObjectInputStream in = new ObjectInputStream(fi)) {

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

    //Sortie d'objet
    System.out.println(p.name);
    System.out.println(p.age);
} catch (IOException | ClassNotFoundException ex) {
    System.out.println(ex.getMessage());
}

production

#------Sérialiser------
Create person.
#------Désérialiser------
alex
30

Résumé:

1. Parce que ce sont les données de l'objet qui ont été sérialisées, pas la classe Person.class requis pour la désérialisation
2. Puisque Create person. n'est pas affiché, aucun constructeur n'est requis lors de la désérialisation.

Plusieurs objets entrant / sortant

//Sérioriser
out.writeObject(new Person("alex", 30));
out.writeObject(new Student("king", 20));

//Taille Desilia
Person p = (Person) in.readObject();
Student s = (Student) in.readObject();

Résumé:

1. Une commande existe et doit être désérialisée dans l'ordre dans lequel elle a été sérialisée.
2. Si l'ordre est différent, "Exception dans le thread" main "java.lang.ClassCastException: io.serializable.Person ne peut pas être converti en io.serializable.Student" se produira.

Avoir une référence d'objet

//Sérioriser
out.writeObject(new Teacher("alex", 30, new Student("king", 20)));

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

Résumé:

1. L'objet référencé est également sérialisé.
2. Si l'objet référencé n'implémente pas Serializable, "l'écriture abandonnée; java.io.NotSerializableException: io.serializable.Student" se produira.

Plusieurs objets ont la même référence

python

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

//Taille Desilia
Teacher alex = (Teacher) in.readObject();
Teacher bill = (Teacher) in.readObject();
System.out.println(alex.student == bill.student); // true

Résumé: même si la même référence est désérialisée, un seul objet sera référencé comme avant la sérialisation. Sérialiser l'image:

serialVersionUID Il s'agit de confirmer que les classes au moment de la sérialisation et de la désérialisation sont les mêmes. Si le recto et le verso sont différents, "Exception dans le thread" main "java.io.InvalidClassException" se produira.

• Comment écrire
• Écrivez explicitement private static final long serialVersionUID = 512L;
• jvm calcule en fonction des informations de classe
• Les changements de méthode n'ont aucun effet
• les changements de membres statiques n'ont aucun effet
• Les changements apportés aux méthodes non statiques ont un impact
• Peut être calculé manuellement avec bin / serialver

prime

Redirection d'E / S standard

java représente l'entrée et la sortie standard dans System.in et System.out, avec clavier et affichage par défaut.

• Méthode de redirection IO standard
  • System#setErr(PrintStream err)
  • System#setIn(InputStream in)
  • System#setOut(PrintStream out)

Redirection de sortie standard

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());
}

Viennent ensuite NIO et NIO.2.

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