java类中map属性和泛型T如何序列化

Java 中的 `Map` 属性和泛型 `T` 都可以通过序列化转换为字节序列，以便在网络上传输或将其存储在磁盘上。

对于 `Map` 属性的序列化，我们可以在包含该属性的类中实现 `Serializable` 接口，并将 `Map` 属性标记为 `transient`，以便在序列化对象时跳过该属性。然后，我们可以在 `writeObject()` 和 `readObject()` 方法中手动序列化和反序列化该属性。

以下是一个示例代码，展示了如何序列化一个包含 `Map` 属性的类：

import java.io.*;
import java.util.*;

public class MyClass implements Serializable {
    private transient Map<String, Integer> map;
    private String name;
    
    public MyClass() {
        map = new HashMap<>();
        map.put("A", 1);
        map.put("B", 2);
        map.put("C", 3);
        name = "MyClass";
    }
    
    private void writeObject(ObjectOutputStream out) throws IOException {
        out.defaultWriteObject();
        out.writeInt(map.size());
        for (Map.Entry<String, Integer> entry: map.entrySet()) {
            out.writeObject(entry.getKey());
            out.writeObject(entry.getValue());
        }
    }
    
    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
        in.defaultReadObject();
        int size = in.readInt();
        map = new HashMap<>(size);
        for (int i = 0; i < size; i++) {
            String key = (String) in.readObject();
            Integer value = (Integer) in.readObject();
            map.put(key, value);
        }
    }
    
    @Override
    public String toString() {
        return "MyClass{name='" + name + "', map=" + map + "}";
    }
    
    public static void main(String[] args) {
        MyClass myClass = new MyClass();
        System.out.println("Original object: " + myClass);
        
        try {
            // 序列化
            FileOutputStream fos = new FileOutputStream("myclass.ser");
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(myClass);
            oos.close();

            // 反序列化
            FileInputStream fis = new FileInputStream("myclass.ser");
            ObjectInputStream ois = new ObjectInputStream(fis);
            MyClass newMyClass = (MyClass) ois.readObject();
            ois.close();

            // 输出反序列化后的对象
            System.out.println("Deserialized object: " + newMyClass);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

在上述代码中，`Map` 属性被标记为 `transient`，并在 `writeObject()` 和 `readObject()` 方法中手动序列化和反序列化。序列化时，我们首先调用 `defaultWriteObject()` 方法将对象的默认字段序列化，然后手动序列化 `Map` 属性。反序列化时，我们首先调用 `defaultReadObject()` 方法读取对象的默认字段，然后手动反序列化 `Map` 属性。

对于泛型 `T` 的序列化，我们可以在序列化和反序列化时使用 Java 的类型擦除机制。具体来说，在序列化时，我们可以将 `T` 视为 `Object`，并将其强制转换为 `Object` 类型；在反序列化时，我们可以将反序列化后的 `Object` 对象强制转换为 `T` 类型。

以下是一个示例代码，展示了如何序列化一个包含泛型 `T` 属性的类：

import java.io.*;

public class MyClass<T> implements Serializable {
    private T data;
    
    public MyClass(T data) {
        this.data = data;
    }
    
    public T getData() {
        return data;
    }
    
    @Override
    public String toString() {
        return "MyClass{data=" + data + "}";
    }
    
    public static void main(String[] args) {
        MyClass<String> myClass = new MyClass<>("Hello, world!");
        System.out.println("Original object: " + myClass);
        
        try {
            // 序列化
            FileOutputStream fos = new FileOutputStream("myclass.ser");
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(myClass);
            oos.close();

            // 反序列化
            FileInputStream fis = new FileInputStream("myclass.ser");
            ObjectInputStream ois = new ObjectInputStream(fis);
            MyClass<?> newMyClass = (MyClass<?>) ois.readObject();
            ois.close();

            // 输出反序列化后的对象
            System.out.println("Deserialized object: " + newMyClass);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

在上述代码中，我们创建了一个泛型 `T` 类型为 `String` 的 `MyClass` 对象，并将其序列化和反序列化。在序列化时，我们将泛型 `T` 视为 `Object`，并将其强制转换为 `Object` 类型；在反序列化时，我们将反序列化后的 `Object` 对象强制转换为 `T` 类型。