Wie implementiert man die Serialisierung und Deserialisierung von Objekten in Java? (zwei Methoden)

Der Inhalt dieses Artikels befasst sich mit der Implementierung der Serialisierung und Deserialisierung von Objekten in Java. (Zwei Methoden) haben einen gewissen Referenzwert. Freunde in Not können sich darauf beziehen.

Einführung:

Serialisierung ist der Prozess der Umwandlung der Zustandsinformationen eines Objekts in eine Form, die gespeichert oder übertragen werden kann. Während der Serialisierung schreibt das Objekt seinen vergangenen Zustand in einen temporären oder dauerhaften Speicher. Unter Deserialisierung versteht man den Prozess der Neuerstellung des Objekts aus dem temporären oder dauerhaften Speicher.

Die Rolle der Serialisierung:

Es ist wie das Speichern von Daten in der Datenbank und das Beibehalten einiger Daten in der Datenbank. Manchmal ist es notwendig, das Objekt beizubehalten, obwohl der Objektstatus dort bestehen bleibt Es gibt viele Möglichkeiten, aber Java bietet uns eine sehr praktische Möglichkeit: Durch die Serialisierung kann eine direkte Konvertierung zwischen Objekten und Dateien realisiert werden, und die Implementierungsdetails bleiben uns verborgen.

Drei spezifische Verwendungszwecke:

Persistentes Speichern der Statusinformationen des Objekts auf der Festplatte

Übertragen der Objektinformationen über das Netzwerk

Deep Cloning ( Das heißt, Serialisierung und dann Deserialisierung)

Methode 1: Implementieren Sie die Serializable-Schnittstelle, implementieren Sie die Serializable-Schnittstelle über den Serialisierungsstream

und serialisieren und deserialisieren Sie das Objekt über ObjectOutputStream und ObjectInputStream.

import java.io.*;
public class User implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public static void main(String[] args) throws IOException, ClassNotFoundException {
//        User user = new User("gol",22);
//        ByteArrayOutputStream bo = new ByteArrayOutputStream();
//        ObjectOutputStream oo = new ObjectOutputStream(bo);
//        oo.writeObject(user);//序列化.user写入字节数组流中
//        ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());
//        ObjectInputStream oi = new ObjectInputStream(bi);
//        User userSer = (User) oi.readObject();//反序列化
//        System.out.println(userSer);
        User user = new User("gol",22);
        FileOutputStream fos = new FileOutputStream("a.txt");
        ObjectOutputStream oo = new ObjectOutputStream(fos);
        oo.writeObject(user);//序列化.user写入文件中
        FileInputStream fis = new FileInputStream("a.txt");
        ObjectInputStream oi = new ObjectInputStream(fis);
        User userSer = (User) oi.readObject();//反序列化
        System.out.println(userSer);
        oi.close();
        fis.close();
        oo.close();
        fos.close();
    }
}

Methode 2: Implementieren Sie die Externalizable-Schnittstelle und schreiben Sie die Methoden writeExternal und readExternal neu

Die Externalizable-Schnittstelle erbt die Serializable-Schnittstelle und kapselt zwei Methoden für uns, eine für die Serialisierung und eine für Deserialisieren. Diese Methode serialisiert Attribute. Beachten Sie, dass der Transient-Modifikator bei dieser Methode seine Wirkung verliert. Das heißt, die durch Transient geänderten Attribute werden weiterhin serialisiert, solange Sie das Attribut in der writeExternal-Methode serialisieren.

import java.io.*;
public class User implements Externalizable {
    private static final long serialVersionUID = 1L;
    private  String name;
    private  int age;

    public User() {
    }

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeObject(this.name);//将属性分别序列化
        out.writeObject(this.age);
    }

    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        this.name=(String)in.readObject();//反序列化属性
        this.age=(int)in.readObject();
    }

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        FileOutputStream fos = new FileOutputStream("a.txt");
        ObjectOutputStream oo = new ObjectOutputStream(fos);
        FileInputStream fis = new FileInputStream("a.txt");
        ObjectInputStream oi = new ObjectInputStream(fis);
        User user = new User("gol",19);
        user.writeExternal(oo);//序列化
        User userEnr = new User();
        userEnr.readExternal(oi);//反序列化
        System.out.println(userEnr);
        oi.close();
        fis.close();
        oo.close();
        fos.close();
    }
}

Zusammenfassung:

Beachten Sie die folgenden drei Punkte:

Die Serializable-Schnittstelle ist eine Markierungsschnittstelle und eine leere Schnittstelle, die verwendet wird, um zu identifizieren, dass die Klasse serialisiert werden kann.

transient ist ein Attributmodifikator, und die von ihm geänderten Attribute werden nicht serialisiert. Wenn Sie jedoch Methode 2 verwenden, geben Sie eindeutig an, dass die Attributserialisierung auch serialisiert werden kann.

Das serialVersionUID-Attribut ist die Serialisierungs-ID der Klasse. Wenn das serialVersionUID-Attribut des serialisierten Objekts und des deserialisierten Objekts unterschiedlich ist, wird ein Fehler gemeldet.

Das obige ist der detaillierte Inhalt vonWie implementiert man die Serialisierung und Deserialisierung von Objekten in Java? (zwei Methoden). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!