Java中序列化和反序列化的完整讲解

序列化和反序列化的概念

序列化（Serialization）是将一个对象变成字节流的过程，可以将对象的状态信息保存在磁盘上或者通过网络传输到另一个远程对象上。

反序列化（Deserialization）是将字节流还原为对象的过程，可以从磁盘或者网络中读取字节流，并将其还原为Java对象。

Java中提供了ObjectOutputStream和ObjectInputStream两个类来支持对象的序列化和反序列化。

序列化的过程

Java对象序列化的过程是将Java对象的状态信息写入到流中。序列化对象需要满足以下要求：

1. 该对象的类必须实现Serializable接口。Serializable是一个标记接口。

2. 静态变量不能被序列化。

以下是一个简单的Java对象的定义：

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

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

如何将这个对象序列化呢？只需要按照以下步骤：

public static void main(String[] args) {
    Person person = new Person("Jack", 20);
    try (ObjectOutputStream oos = new ObjectOutputStream(
            new FileOutputStream(new File("person.dat")))) {
        oos.writeObject(person);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

上面的代码创建了一个Person对象，并将其写入到名为person.dat的文件中。

反序列化的过程

Java对象反序列化的过程是将流中的对象信息读取出来，并生成一个Java对象。反序列化对象需要满足以下要求：

1. 必须存在一个类，该类实现了Serializable接口。

以下是进行反序列化的代码：

public static void main(String[] args) {
    try (ObjectInputStream ois = new ObjectInputStream(
            new FileInputStream(new File("person.dat")))) {
        Person person = (Person) ois.readObject();
        System.out.println(person.getName());
        System.out.println(person.getAge());
    } catch (IOException | ClassNotFoundException e) {
        e.printStackTrace();
    }
}

上面的代码将person.dat文件中的数据读取出来，并将其转化为一个Person对象。

自定义序列化

当Java对象的序列化和反序列化需要特殊处理时，可以实现Serializable接口中的writeObject和readObject方法来进行自定义的序列化和反序列化操作。

以下是一个自定义的Java对象：

public class Book implements Serializable {
    private int id;
    private String title;

    Book(int id, String title) {
        this.id = id;
        this.title = title;
    }

    private void writeObject(ObjectOutputStream out) throws IOException {
        out.writeInt(id);
        out.writeUTF(title.toUpperCase());
    }

    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
        id = in.readInt();
        title = in.readUTF().toLowerCase();
    }

    @Override
    public String toString() {
        return "Book{" +
                "id=" + id +
                ", title='" + title + '\'' +
                '}';
    }
}

在上面的例子中，我们为Book对象实现了自定义的序列化和反序列化方法，将title字段转化为大写字母或小写字母，以此为例进行自定义的序列化和反序列化。

以下是一个使用自定义序列化方法的例子：

public static void main(String[] args) {
    Book book1 = new Book(1, "Thinking in Java");
    Book book2 = new Book(2, "Effective Java");
    try (ObjectOutputStream oos = new ObjectOutputStream(
            new FileOutputStream(new File("books.dat")))) {
        oos.writeObject(book1);
        oos.writeObject(book2);
    } catch (IOException e) {
        e.printStackTrace();
    }
    try (ObjectInputStream ois = new ObjectInputStream(
            new FileInputStream(new File("books.dat")))) {
        Book book3 = (Book) ois.readObject();
        Book book4 = (Book) ois.readObject();
        System.out.println(book3);
        System.out.println(book4);
    } catch (IOException | ClassNotFoundException e) {
        e.printStackTrace();
    }
}

上面的代码创建了一个包含两个Book对象的books.dat文件，并使用自定义的反序列化方法将其读取出来。

总结

Java对象序列化和反序列化是Java中非常重要的概念，它允许我们在不同的应用中传递Java对象，或者将Java对象保存在磁盘上。

序列化的过程是将Java对象的状态信息写入到流中，反序列化的过程是将流中的对象信息读取出来，并生成一个Java对象。在自定义序列化和反序列化时，可以实现Serializable接口中的writeObject和readObject方法来进行特殊处理。