序列化和反序列化（干货代码）

----------------------------需要序列化的对象--------------------------------------------

package com.IO流.day_05对象流序列化;

import java.io.Serializable;

/**
 * Person需要满足如下要求：方可序列化
 * 1.需要实现接口：Serializable
 * 2.当前类提供了一个全局常量：serialVersionUID'
 * 3.除了当前Person类需要实现serializable接口之外，还必须保证其内部所有的属性也必须是可序列化的（
 * 4 补充：OjbectOUtputstream和OjbectInputstream不能序列化static和transient修饰的成员变量:static int age;transient int age）
 * @ClassName Person
 * @Description TODO
 * @Date 2022/5/6 10:16
 * @Author MI
 * @Version 1.0
 **/
public class Person implements Serializable {
    private static final long serialVersionUID = 42200929939L;
    private String name;
    private int age;
    private int id;
private Account account;
    public Person() {
    }

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

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

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", id=" + id +
                ",acount="+account+
                '}';
    }

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }
}
class Account implements Serializable{
    public static final long SerialVersionUID=4455622l;
    private double balance;

    public Account(double balance) {
        this.balance = balance;
    }

    @Override
    public String toString() {
        return "Account{" +
                "balance=" + balance +
                '}';
    }

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }
}

------------------------------------------------序列化 和反序列化实现-

package com.IO流.day_05对象流序列化;

import org.testng.annotations.Test;

import java.io.*;

/**
 * 对象流的使用
 * 1.ObjectInputStream,ObjectOutputStream
 * 2.作用：用于存储和读取基本数据类型或对象的处理流，他的强大之处就是可以把java中的对象写入数据源中
 * 3.要想一个java对象是可以序列化的，需要满足相应的要求，
 * 4.序列化机制
 * 对象序列化机制允许把内存中的java对象转换成平台无关的二进制流，从而允许把这种二进制流持久的保存在磁盘中，
 * 或通过网络将这种二进制流传输到另一个网络节点
 * 当其他程序获取了这种二进制流，就可以恢复成原来的java对象
 *
 * @ClassName ObjectInputStreamTest
 * @Description
 * @Date 2022/5/6 9:55
 * @Author MI
 * @Version 1.0
 **/
public class ObjectInputStreamTest {
    /*
    序列化过程：将内存中的java对象保存到磁盘中或通过网络传输出去
    使用ObjectOutputStream实现
     */
    @Test
    public void test() {
        ObjectOutputStream objectOutputStream = null;
        try {
            objectOutputStream = new ObjectOutputStream(new FileOutputStream("Object.dat"));//
            objectOutputStream.writeObject(new String("我爱北京天安门"));
            objectOutputStream.flush();

            objectOutputStream.writeObject(new Person("xiaomi", 20, 1001));
            objectOutputStream.flush();

            objectOutputStream.writeObject(new Person("huawei", 22, 1002, new Account(8880.0)));
            objectOutputStream.flush();
            System.out.println("<succeed>");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (objectOutputStream != null) {
                try {
                    objectOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 序列化2演示
     */
    @Test
    public void test2(){
        Person sa = new Person("啊sa", 28, 1009);
        //使用ObjectOutPutStream序列化Person对象并将其序列化成字节序列化写入test.txt文件
        try {
            FileOutputStream fileOutputStream = new FileOutputStream("F:\\序列化\\test.txt"); //写入硬盘地址
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
            objectOutputStream.writeObject(sa);
            objectOutputStream.flush();
            objectOutputStream.close();
            System.out.println("succeed");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {

        }

    }

    /*
  返序列化：将磁盘文件中的对象还原为内存中的一个java对象
  使用Objectinputstream来实现
   */
    @Test
    public void testObjectInputStream() {
        ObjectInputStream objectInputStream = null;
        try {
            objectInputStream = new ObjectInputStream(new FileInputStream("Object.dat"));
            Object o = objectInputStream.readObject();

            String str = (String) o;
            System.out.println(str);//序列化顺序读取

            Person p = (Person) objectInputStream.readObject();
            System.out.println(p);

            Object o1 = objectInputStream.readObject();
            Person p2 = (Person) o1;
            System.out.println(p2);

        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            if (objectInputStream != null) {
                try {
                    objectInputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

------------------------------------------------