对象的序列化

对象的序列化机制允许把内存中的 Java 对象转换成平台无关的二进制流，从而允许把这种二进制流持久地保存在磁盘上，或通过网络将这种二进制流传输到另一个网络节点。当其他程序获取了这种二进制流，就可以恢复成原来的 Java 对象

序列化的好处在于可将任何实现了 Serializable 接口的对象转化为字节数据，使其在保存和传输时可被还原

如果需要让某个对象支持序列化机制，则必须让对象所属的类及其属性是可序列化的（默认情况下，基本数据类型可序列化）

实现序列化的两个接口

Serializable（主要使用）

Externalizable

序列化与反序列化

序列化：用 ObjectOutputStream 类保存基本类型数据或对象的机制

反序列化：用 ObjectInputStream 类读取基本类型数据或对象的机制

注：ObjectOutputStream 和 ObjectInputStream 不能序列化 static 和 transient 修饰的成员变量

序列化与反序列化字符串

import org.junit.Test;
import java.io.*;

public class testObjectInputOutputStream {
    //序列化：将内存中的 Java 对象保存到磁盘中或通过网络传输出去
    @Test
    public void testObjectOutputStream() {
        ObjectOutputStream oos = null;
        try {
            oos = new ObjectOutputStream(new FileOutputStream("object1.dat"));
            oos.writeObject(new String("雪之下雪乃"));
            oos.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (oos != null)
                oos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    //反序列化：将磁盘文件中的对象还原为内存中的一个 Java 对象
    @Test
    public void testObjectInputStream(){
        ObjectInputStream ois = null;
        try {
            ois = new ObjectInputStream(new FileInputStream("object1.dat"));
            Object obj = ois.readObject();
            String str = (String)obj;
            System.out.println(str);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            try {
                if (ois != null)
                ois.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

>>> 雪之下雪乃

序列化与反序列化对象

对象需满足如下要求，方可序列化

1. 需要实现接口：Serializable

2. 当前类提供一个全局常量：serialVersionUID

class Person implements Serializable{
    public static final long serialVersionUID = 34515365752L;
    
    private String name;
    private int age;
    
    public Person() {
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

package IOTest;
import org.junit.Test;
import java.io.*;

public class testObjectInputOutputStream {
    @Test
    public void testObjectOutputStream() {
        ObjectOutputStream oos = null;
        try {
            oos = new ObjectOutputStream(new FileOutputStream("object1.dat"));
            oos.writeObject(new Person("远坂凛",18));
            oos.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (oos != null)
                oos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    @Test
    public void testObjectInputStream(){
        ObjectInputStream ois = null;
        try {
            ois = new ObjectInputStream(new FileInputStream("object1.dat"));
            Person p = (Person)ois.readObject();
            System.out.println(p);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            try {
                if (ois != null)
                ois.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

>>> Person{name='远坂凛', age=18}