Comment implémenter la sérialisation et la désérialisation d'objets en Java ? (deux méthodes)

Le contenu de cet article explique comment implémenter la sérialisation et la désérialisation d'objets en Java ? (Deux méthodes) ont une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer. J'espère que cela vous sera utile.

Introduction :

La sérialisation est le processus de conversion des informations d'état d'un objet sous une forme qui peut être stockée ou transmise. Lors de la sérialisation, l'objet écrit son état passé dans un stockage temporaire ou persistant, la désérialisation est le processus de recréation d'un objet à partir d'un stockage temporaire ou persistant.

Le rôle de la sérialisation :

C'est comme stocker des données dans la base de données et conserver certaines données dans la base de données. Parfois, il est nécessaire de conserver l'objet, même si l'état de l'objet y est conservé. Il existe de nombreuses façons, mais Java nous offre un moyen très pratique, à savoir que la sérialisation peut réaliser une conversion directe entre les objets et les fichiers, et les détails d'implémentation nous sont cachés.

Trois utilisations spécifiques :

Enregistrer de manière persistante les informations d'état de l'objet sur le disque dur

Transmettre les informations de l'objet sur le réseau

Clonage profond ( C'est-à-dire la sérialisation puis la désérialisation)

Méthode 1 : implémentez l'interface Serialisable via le flux de sérialisation

, et sérialisez et désérialisez l'objet via ObjectOutputStream et 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();
    }
}

Méthode 2 : implémenter l'interface externalisable et remplacer les méthodes writeExternal et readExternal

L'interface externalisable hérite de l'interface sérialisable et encapsule deux méthodes pour nous, une pour la sérialisation et une pour l'utilisation pour la désérialisation. Cette méthode sérialise les attributs. Notez que le modificateur transient perdra son effet dans cette méthode, c'est-à-dire que les attributs modifiés par transient seront toujours sérialisés tant que vous sérialiserez l'attribut dans la méthode writeExternal.

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

Résumé :

Notez les trois points suivants :

L'interface Serialisable est une interface marqueur et une interface vide, utilisée pour identifier que la classe peut être sérialisée .

transient est un modificateur d'attribut, et les attributs modifiés par celui-ci ne seront pas sérialisés. Cependant, si vous utilisez la méthode 2, indiquant clairement que la sérialisation de l'attribut peut également être sérialisée.

L'attribut SerialVersionUID est l'ID de sérialisation de la classe. Si l'attribut SerialVersionUID de l'objet sérialisé et de l'objet désérialisé sont différents, une erreur sera signalée.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!