序列化和反序列化、部分序列化

1. 序列化：将程序的对象以文件的形式存储也就是转化为字节序列过程，把数据转换为可以存储或者传输的形式。按照对象的内存序列存储的不是眼睛能看出来的。
2. 反序列化：把文件的存储对象读取到程序中，就是将字节序列转换为目标对象过程，转换为当初数据的对象

一、为什么要进行序列化

计算机中任何数据（文本、图片、视频、音乐等等）都是以二进制的形式存储的，在序列化期间，对象将其当前状态写入到临时或持久性存储区。以后，可以通过从存储区中读取或反序列化对象的状态，重新创建该对象。通过序列化将对象转化为字节序列化，然后通过I/O传输，在进行反序列化获取我们想要的对象，最后完成通信。

特点

1、以某种存储形式使自定义du自定义对象永久保存；

2、将对象从一个地方传递到另一个地方。

3、使程序更具维护性。

序列化和反序列化具体实现

1.   只有实现了Serializable或者Externalizable接口的类的对象才能被序列化。
2. ObjectOutputStream 将 Java 对象的基本数据类型和图形写入 OutputStream（字节流）。
3. ObjectInputStream是对以前使用 ObjectOutputStream 写入的基本数据和对象进行反序列化。

•          代码示例
• 定义要序列化类

//使用Serializable接口实现序列化
public class Student implements Serializable {
    private String stuNum;//字符类型的学生号
    private String stuName;//字符类型的学生姓名
    private List<String> teacherList;//List集合类型的教室姓名

    @Override
    public String toString() {
        return "Student{" +
                "stuNum='" + stuNum + '\'' +
                ", stuName='" + stuName + '\'' +
                ", teacherList=" + teacherList +
                '}';
    }

    public Student() {
    }

    public Student(String stuNum, String stuName, List<String> teacherList) {
        this.stuNum = stuNum;
        this.stuName = stuName;
        this.teacherList = teacherList;
    }

    public String getStuNum() {
        return stuNum;
    }

    public void setStuNum(String stuNum) {
        this.stuNum = stuNum;
    }

    public String getStuName() {
        return stuName;
    }

    public void setStuName(String stuName) {
        this.stuName = stuName;
    }

    public List<String> getTeacherList() {
        return teacherList;
    }

    public void setTeacherList(List<String> teacherList) {
        this.teacherList = teacherList;
    }
}

工具类定义序列化和反序列化方法

public class MySerializeUtil {
//    序列化方法
    public  static  void mySerializeUtil(Object obj,String fileName) throws IOException {
//       创建字节流对象
        OutputStream out = new FileOutputStream(fileName);
        ObjectOutputStream objOut = new ObjectOutputStream(out);
      objOut.writeObject(obj);
        objOut.close();
    }
//    反序列化方法
    public static Object mydeSerializeUtil(String fileName) throws IOException, ClassNotFoundException {
       InputStream in = new FileInputStream(fileName);
       ObjectInputStream objIn = new ObjectInputStream(in);
       Object obj = objIn.readObject();
       return obj;
    }
}

测试类

public class MainTest {
    public static void main(String[] args) {
//创建List集合对象
        List<String> teacherList = new ArrayList<>();
//在集合中加入老师姓名属性内容
        teacherList.add("张三");
        teacherList.add("李四");
//创建学生类对象及内容
        Student stu1=new Student("1001","王五" ,teacherList);
        System.out.println("原始对象："+stu1);
//内容存储的路径文件
        String fileName ="e://stu01.txt";
        try{
            MySerializeUtil.mySerializeUtil(stu1,fileName);
            System.out.println("序列化成功");
//反序列化内容需要接收
            Object obj =MySerializeUtil.mydeSerializeUtil(fileName);
//需要用到对象的强制类型转换时，需要使用instanceof进行判断。`
            if(obj instanceof Student){
                Student stu2 = (Student) obj;
                System.out.println("反序列化成功："+stu2);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

测试结果

序列化结果：

​

 返序列化结果：

​

1. 部分属性的序列化

• 实现部分字段序列化的方式：

• 使用transient修饰符

• 使用static修饰符

• 默认方法writeObject和readObject。

• Externalizable接口

使用transient修饰符

transient修饰符修饰的属性也不会参与序列化和反序列化。

public class Student implements Serializable{
    private   transient String stuNam;
    private int stuNum;
    private List<String> teacherNam;
....
//在第一个属性加入transient，跟上边代码一样只是加入了transient

测试结果：stuNam为空，说明该属性对象为参加序列化

使用static修饰符

static修饰符修饰的属性也不会参与序列化和反序列化。

public class Student implements Serializable{
    private    String stuNam;
    private static int stuNum;
    private List<String> teacherNam;
....
//在第二个属性加入 static，跟上边代码一样只是加入了 static

       try {
            Tool.tool1(stu1,fileName);
            System.out.println("写入成功");
           Object obj = Tool.tools(fileName);
//对加有Static修饰的属性进行修改，若发生改变未参与序列化，否则参加序列化
           stu1.setStuNum(100);
           if(obj instanceof Student){
               Student stu2 = (Student) obj;
               System.out.println("读取的对象："+stu2);
           }
            System.out.println("读取成功");
        } catch (Exception e) {
            e.printStackTrace();
        }
....
//该代码和上边测试类代码一样只是插入了第六行代码

测试结果：stuNam结果发生改变说明该属性未加入序列化

 默认方法writeObject和readObject

默认方法writeObject和readObject修饰符修饰的属性也会参与序列化和反序列化。

public class Student implements Serializable{
    private   String stuNam;
    private int stuNum;
    private List<String> teacherNam;
    private void writeObject(java.io.ObjectOutputStream out) throws IOException {
        System.out.println("----");
        out.writeObject(stuNam);
        out.writeObject(stuNum);

    }
    private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException {
        System.out.println("1----");
        stuNam = (String) in.readObject();
        stuNum =(int)in.readObject();

    }
....

结果：我们在添加的方法中只对stuNum和stuName属性做了序列化和反序列化的操作，因此只有这个两个属 性可以被序列化和反序列化。

 Externalizable接口实现Java序列化

• Externalizable继承自Serializable，使用Externalizable接口需要实现readExternal方法和 writeExternal方法来实现序列化和反序列化。

public class Student implements Externalizable {

private String stuNum;

private String stuName;

private List<String> teacherList;

@Override
public void writeExternal(ObjectOutput out) throws IOException {
out.writeObject(stuNum);
out.writeObject(stuName);
//out.writeObject(teacherList);
}
@Override
public void readExternal(ObjectInput in) throws IOException,
ClassNotFoundException {
stuNum= (String) in.readObject();
stuName= (String) in.readObject();
//teacherList= (List<String>) in.readObject();
}

结果：