Java基础-序列化和反序列化

1.序列化和反序列化概述

1.java.io.NotSerializableException
Student对象不支持序列化
2.参与序列化和反序列化的对象，必须实现Serializable接口
3.注意：通过源代码发现：Serializable接口只是一个标志接口

public interface Serializable{
}

这个接口当中什么代码也没有，
那么它起到什么作用呢？
起到标识的作用，java虚拟机看到这个类实现了这个接口，可能会对这个类进行特殊待遇。
Serializable这个标志接口是给java虚拟机看的，java虚拟机看到这个接口，会为该类自动生成一个序列化版本号。

2.序列化

public class Student implements Serializable{
	private int no;
	private String name;
	public Student() {
	}
	public Student(int no, String name) {
		this.no = no;
		this.name = name;
	}
	public int getNo() {
		return no;
	}
	public void setNo(int no) {
		this.no = no;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@Override
	public String toString() {
		return "Student [no=" + no + ", name=" + name + "]";
	}
	
}

public class ObjectOutputStreamTest01 {
	public static void main(String[] args) {
		//创建java对象
		Student s=new Student(111,"zhangsan");
		
		try {
			//序列化
			ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("students"));
			//序列化对象
			oos.writeObject(s);
			//刷新
			oos.flush();
			//关闭
			oos.close();
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
}

3.反序列化

public class ObjectInputStreamTest02 {
	public static void main(String[] args) {
		try {
			ObjectInputStream ois=new ObjectInputStream(new FileInputStream("students"));
			//开始反序列化。读
			Object obj=ois.readObject();
			//反序列化回来是一个学生对象，所以会调用学生对象的toString方法
			System.out.println(obj);
			ois.close();
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

4.序列化多个对象

一次序列化多个对象呢？
可以，可以将对象放到集合当中，序列化集合
提示：
参与序列化的ArrayList集合以及集合中元素User都需要实现java.io.Serializable接口

public class User implements Serializable{
	private int no;
	private String name;
	public User() {
		super();
	}
	public User(int no, String name) {
		super();
		this.no = no;
		this.name = name;
	}
	public int getNo() {
		return no;
	}
	public void setNo(int no) {
		this.no = no;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@Override
	public String toString() {
		return "User [no=" + no + ", name=" + name + "]";
	}
}

public class ObjectOutputStreamTest02 {
	public static void main(String[] args) {
		List<User> userList=new ArrayList<>();
		userList.add(new User(1,"zhangsan"));
		userList.add(new User(2,"lisi"));
		userList.add(new User(3,"wangwu"));
		userList.add(new User(4,"zhouliu"));
		ObjectOutputStream oos;
		try {
			oos = new ObjectOutputStream(new FileOutputStream("users"));
			//序列化一个集合，这个集合对象中放了很多其他的对象
			oos.writeObject(userList);
			oos.flush();
			oos.close();
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
}

/*反序列化*/
public class ObjectInputStreamTest03 {
	public static void main(String[] args) {
		ObjectInputStream ois;
		try {
			ois = new ObjectInputStream(new FileInputStream("users"));
			List<User> userList=(List<User>)ois.readObject();
			for(User user:userList){
				System.out.println(user);
			}
			ois.close();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
}

当不想要某个字段参加序列化，就是用transient关键字，表示游离的，不参与序列化操作。

5.序列化版本号（重要）

过了很久，Student这个类源代码改动了，源代码改动之后，需要重新编译，编译之后生成了全新的字节码文件，并且class文件再次运行的时候，Java虚拟机生成的序列化版本号也会发生相应的改变。
比如在student类中加了age属性

java.io.InvalidClassException: FileInputStream.Student; local class incompatible: stream classdesc serialVersionUID = 2177219699722857068, local class serialVersionUID = 4538774260763420100

此时出了问题。
java语言中是采用什么机制来区分类的
第一：首先通过类名进行比对，如果类名不一样，肯定不是同一个类
第二：如果类名一样，在怎么进行类的区分呢？通过序列化版本号
小明编写了一个类：com.yujie.java.bean.Student
小红编写了一个类：com.yujie.java.bean.Student
不同的人编写了同一个类，但这个两个类确实不是同一个类，这个时候序列化版本就起上作用了。
对于java虚拟机来说，java虚拟机时可以区分开这两个类的，因为这两个类都实现了Serializable接口，都有默认的序列化版本号，他们的序列化版本号不一样，所以区分开了。这就是序列化版本号的好处
请思考：这种自动生成序列化版本号有什么缺陷
这种自动生成的序列化版本号缺点是：一旦代码确定之后，不能进行后续修改，因为只要修改，必然会重新编译，此时会生成全新的序列化版本号，这个时候Java虚拟机会认为这是一个全新的类。（这样就不好了）
最终结论：
凡是一个类实现了Serializable接口，建议给这个类提供一个固定不变的序列化版本号，这样，以后这个了即使代码修改了，但是版本号不变，java虚拟机会认为是同一个类。
建议将序列化版本号手动的写出来，不建议自动生成。
java虚拟机识别一个类的时候先通过类名，如果类名一致，就看序列化版本号

public class Student implements Serializable{
private static final long serialVersionUID=1L;

idea和eclipse可以自动序列化版本号