什么是java的序列化和反序列化？
1、什么是序列化？为什么要序列化？
Java 序列化就是指将对象转换为字节序列的过程，而反序列化则是只将字节序列转换成目标对象的过程。
我们都知道，在进行浏览器访问的时候，我们看到的文本、图片、音频、视频等都是通过二进制序列进行传输的，那么如果我们需要将Java对象进行传输的时候，是不是也应该先将对象进行序列化？答案是肯定的，我们需要先将Java对象进行序列化，然后通过网络，IO进行传输，当到达目的地之后，再进行反序列化获取到我们想要的对象，最后完成通信。
2、如何实现序列化
2.1、使用到JDK中关键类 ObjectOutputStream 和ObjectInputStream
ObjectOutputStream 类中：通过使用writeObject(Object object) 方法，将对象以二进制格式进行写入。
ObjectInputStream 类中：通过使用readObject（）方法，从输入流中读取二进制流，转换成对象。
2.2、目标对象需要先实现 Seriable接口
我们创建一个Student类：
public class Student implements Serializable {
private static final long serialVersionUID = 3404072173323892464L;
private String name;
private transient String id;
private String age;
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", id='" + id + '\'' +
", age='" + age + '\'' +
public String getAge() {
return age;
public void setAge(String age) {
this.age = age;
public Student(String name, String id) {
System.out.println("args Constructor");
this.name = name;
this.id = id;
public Student() {
System.out.println("none-arg Constructor");
public String getName() {
return name;
public void setName(String name) {
this.name = name;
public String getId() {
return id;
public void setId(String id) {
this.id = id;
代码中Student类实现了Serializable 接口，并且生成了一个版本号：
private static final long serialVersionUID = 3404072173323892464L;
1、Serializable 接口的作用只是用来标识我们这个类是需要进行序列化，并且Serializable 接口中并没有提供任何方法。
2、serialVersionUid 序列化版本号的作用是用来区分我们所编写的类的版本，用于判断反序列化时类的版本是否一直，如果不一致会出现版本不一致异常。
3、transient 关键字，主要用来忽略我们不希望进行序列化的变量
2.3、将对象进行序列或和反序列化
如果你想学习Java可以来这个群，首先是一二六，中间是五三四，最后是五一九，里面有大量的学习资料可以下载。
2.3.1 第一种写入方式：
public static void main(String[] args){
File file = new File("D:/test.txt");
Student student = new Student("孙悟空","12");
try {
ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream(file));
outputStream.writeObject(student);
outputStream.close();
} catch (IOException e) {
e.printStackTrace();
try {
ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(file));
Student s = (Student) objectInputStream.readObject();
System.out.println(s.toString());
System.out.println(s.equals(student));
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
创建对象Student ，然后通过ObjectOutputStream类中的writeObject()方法，将对象输出到文件中。
然后通过ObjectinputStream 类中的readObject（）方法反序列化，获取对象。
2.3.2 第二种写入方式：
在Student 类中实现writeObject（）和readObject（）方法：
private void writeObject(ObjectOutputStream objectOutputStream) throws IOException {
objectOutputStream.defaultWriteObject();
objectOutputStream.writeUTF(id);
private void readObject(ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {
objectInputStream.defaultReadObject();
id = objectInputStream.readUTF();
通过这中方式进行序列话，我们可以自定义想要进行序列化的变量，将输入流和输出流传入对线实例中，然后进行序列化以及反序列化。import java.io.serializable;
* notserializableexception:未序列化异常
* 类通过实现 java.io.serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。
* 该接口居然没有任何方法，类似于这种没有方法的接口被称为标记接口。
* java.io.invalidclassexception:
* cn.itcast_07.person; local class incompatible:
* stream classdesc serialversionuid = -2071565876962058344,
* local class serialversionuid = -8345153069362641443
* 为什么会有问题呢?
*person类实现了序列化接口，那么它本身也应该有一个标记值。
*这个标记值假设是100。
*开始的时候：
*person.class -- id=100
*wirte数据： oos.txt -- id=100
*read数据: oos.txt -- id=100
*现在：
*person.class -- id=200
*wirte数据： oos.txt -- id=100
*read数据: oos.txt -- id=100
* 在实际开发中，可能还需要使用以前写过的数据，不能重新写入。怎么办呢?
* 回想一下原因是因为它们的id值不匹配。
* 每次修改java文件的内容的时候,class文件的id值都会发生改变。
* 而读取文件的时候，会和class文件中的id值进行匹配。所以，就会出问题。
* 但是呢，如果有办法，让这个id值在java文件中是一个固定的值，这样，你修改文件的时候，这个id值还会发生改变吗?
* 不会。现在的关键是我如何能够知道这个id值如何表示的呢?
* 不用担心，不用记住，也没关系，点击鼠标即可。
* 难道没有看到黄色警告线吗?
* 要知道的是：
*看到类实现了序列化接口的时候，要想解决黄色警告线问题，就可以自动产生一个序列化id值。
*而且产生这个值以后，我们对类进行任何改动，它读取以前的数据是没有问题的。
* 注意：
* 一个类中可能有很多的成员变量，有些我不想进行序列化。请问该怎么办呢?
*使用transient关键字声明不需要序列化的成员变量
public class person implements serializable {
private static final long serialversionuid = -2071565876962058344l;
private string name;
// private int age;
private transient int age;
// int age;
public person() {
super();
public person(string name, int age) {
super();
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 + "]";
}把对象转换为字节序列的过程称为对象的序列化。
把字节序列恢复为对象的过程称为对象的反序列化。
关于java对象的反序列化
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.Serializable;
public class $ {
public static void main(String[] args) {
Bean bean = new Bean("abcde", 20);
String path = "D:/a.txt";
try {
// 写入文件
OutputStream os = new FileOutputStream(path);
ObjectOutput ow = new ObjectOutputStream(os);
ow.writeObject(bean);
// 读取
InputStream is = new FileInputStream(path);
ObjectInput oi = new ObjectInputStream(is);
Bean bean2 = (Bean) oi.readObject();
System.out.println(bean2.getName());
System.out.println(bean2.getAge());
} catch (Exception e) {
e.printStackTrace();
}
}
class Bean implements Serializable {
private String name;
private int age;
public Bean(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;
}
}new ObjectInputStream(this.callback_data.getBinaryStream()).readObject(); 反序列化后，利用反射就可以得到里面的属性和方法了呀import java.io.serializable;
* notserializableexception:未序列化异常
* 类通过实现 java.io.serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。
* 该接口居然没有任何方法，类似于这种没有方法的接口被称为标记接口。
* java.io.invalidclassexception:
* cn.itcast_07.person; local class incompatible:
* stream classdesc serialversionuid = -2071565876962058344,
* local class serialversionuid = -8345153069362641443
* 为什么会有问题呢?
*person类实现了序列化接口，那么它本身也应该有一个标记值。
*这个标记值假设是100。
*开始的时候：
*person.class -- id=100
*wirte数据： oos.txt -- id=100
*read数据: oos.txt -- id=100
*现在：
*person.class -- id=200
*wirte数据： oos.txt -- id=100
*read数据: oos.txt -- id=100
* 在实际开发中，可能还需要使用以前写过的数据，不能重新写入。怎么办呢?
* 回想一下原因是因为它们的id值不匹配。
* 每次修改java文件的内容的时候,class文件的id值都会发生改变。
* 而读取文件的时候，会和class文件中的id值进行匹配。所以，就会出问题。
* 但是呢，如果有办法，让这个id值在java文件中是一个固定的值，这样，你修改文件的时候，这个id值还会发生改变吗?
* 不会。现在的关键是我如何能够知道这个id值如何表示的呢?
* 不用担心，不用记住，也没关系，点击鼠标即可。
* 难道没有看到黄色警告线吗?
* 要知道的是：
*看到类实现了序列化接口的时候，要想解决黄色警告线问题，就可以自动产生一个序列化id值。
*而且产生这个值以后，我们对类进行任何改动，它读取以前的数据是没有问题的。
* 注意：
* 一个类中可能有很多的成员变量，有些我不想进行序列化。请问该怎么办呢?
*使用transient关键字声明不需要序列化的成员变量
public class person implements serializable {
private static final long serialversionuid = -2071565876962058344l;
private string name;
// private int age;
private transient int age;
// int age;
public person() {
super();
public person(string name, int age) {
super();
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 + "]";