How to implement serialization and deserialization of objects in Java? (two methods)

What this article brings to you is about how to implement serialization and deserialization of objects in Java? (Two methods) have certain reference value. Friends in need can refer to it. I hope it will be helpful to you.

Introduction:

Serialization is the process of converting the state information of an object into a form that can be stored or transmitted. During serialization, the object writes its past state to a temporary Or persistent storage, deserialization is the process of re-creating an object from temporary or persistent storage.

The role of serialization:

It is like storing data in the database and persisting some data into the database. Sometimes it is necessary to persist the object, although the object state is persisted. There are many ways, but Java provides us with a very convenient way, that is, serialization. Serialization can realize direct conversion between objects and files, and the implementation details are hidden from us.

Three specific uses:

Persistently save the object’s status information to the hard disk

Transmit the object information over the network

Deep cloning (That is, serialization and then deserialization)

Method 1: Implement the Serializable interface, implement the Serializable interface through the serialization stream

, and serialize and deserialize the object through ObjectOutputStream and 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();
    }
}

Method 2: Implement the Externalizable interface and rewrite the writeExternal and readExternal methods

The Externalizable interface inherits the Serializable interface and encapsulates two methods for us, one for serialization and one for Deserialize. This method serializes attributes. Note that the transient modifier will lose its effect in this method. That is to say, the attributes modified by transient will still be serialized as long as you serialize the attribute in the writeExternal method.

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

Summary:

Note the following three points:

The Serializable interface is a mark interface and an empty interface, used to identify that the class can be serialized.

Transient is an attribute modifier, and the attributes modified by it will not be serialized. However, if you use method 2, it is clearly stated that the attribute serialization can also be serialized.

The serialVersionUID attribute is the serialization ID of the class. If the serialVersionUID attribute of the serialized object and the deserialized object are different, an error will be reported.

The above is the detailed content of How to implement serialization and deserialization of objects in Java? (two methods). For more information, please follow other related articles on the PHP Chinese website!