目录
1：对象的序列化
Java序列化是指把Java对象转换为字节序列的过程;而Java反序列化是指把字节序列恢复为Java对象的过程。通过将对象序列化，可以方便的实现对象的传输及保存。
当两个进程进行远程通信时，可以相互发送各种类型的数据，包括文本、图片、音频、视频等，而这些数据都会以二进制序列的形式在网络上传送。那么当两个Java进程进行通信时，实现进程间的对象传送，就需要Java序列化与反序列化了。换句话说，一方面，发送方需要把这个Java对象转换为字节序列，然后在网络上传送;另一方面，接收方需要从字节序列中恢复出Java对象。
2：对象输入流和输出流
在Java中提供了ObjectlnputStream与ObjectOutputStream这两个类用于序列化对象的操作。使用对象输出流输出序列化对象的步骤，有时也称为序列化。使用对象输入流读入对象的过程，有时也称为反序列化。
这两个类是用于存储和读取对象的输入输出流类，不难想象，只要把对象中的所有成员变量都存储起来，就等于保存了这个对象，之后从保存的对象之中再将对象读取进来就可以继续使用此对象。ObjectInputStream与ObjectOutputStream类，可以帮开发者完成保存和读取对象成员变量取值的过程，但要求读写或存储的对象必须实现了java.io.Serializable接口，但Serializable接口中没有定义任何方法，仅仅被用作一种标记，以被编译器作特殊处理。
如下范例所示：
import java.io.*;
public class Person implements Serializable{
private String name;
private int age;
public Person(String name,int age){
this.name = name;
this.age = age;
}
public String toString(){
return " 姓名："+this.name+"，年龄："+this.age;
}
}第2行所中，类Person实现了Serializable接口，所以此类的对象可序列化。下面的范例使用ObjectOutputStream与ObjectInputStream将Person类的对象保存在文件之中
package cn.sz.gl.test05;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
public class Test {
// 以下方法为序列化对象方法，将对象保存在文件之中
public static void serialize(File f) throws Exception{
OutputStream outputFile = new FileOutputStream(f);
ObjectOutputStream cout = new ObjectOutputStream(outputFile)
cout.writeObject(new Person("张三",25));
cout.close();
}
// 以下方法为反序列化对象方法，从文件中读取已经保存的对象
public static void deserialize(File f) throws Exception {
InputStream inputFile = new FileInputStream(f);
ObjectInputStream cin = new ObjectInputStream(inputFile);
Person p = (Person) cin.readObject();
System.out.println(p);
}
public static void main(String args[]) {
File f = new File("SerializedPerson");
serialize(f);
deserialize(f);
}
}序列化实例eg
1：创建学生类，需要实现接口Serializable
package com.File_practise;
import java.io.Serializable;
public class Student implements Serializable {
private static final long SerialServionID = 1l;
private String name ;
private String id ;
public Student() {
}
public Student(String name, String id) {
this.name = name;
this.id = id;
}
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;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", id='" + id + '\'' +
'}';
}
}
2：创建Teacher类
package com.File_practise;
import java.io.Serializable;
public class Teacher implements Serializable {
private String name ;
private String card ;
public Teacher() {
}
public Teacher(String name, String card) {
this.name = name;
this.card = card;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getCard() {
return card;
}
public void setCard(String card) {
this.card = card;
}
@Override
public String toString() {
return "Teacher{" +
"name='" + name + '\'' +
", card='" + card + '\'' +
'}';
}
}3：序列化的使用
package com.File_practise;
import java.io.*;
import java.util.ArrayList;
public class Test1 {
public static void main(String[] args) throws Exception {
// 创建4个不同的对象
Teacher t1 = new Teacher("t1", "qqq");
Teacher t2 = new Teacher("t2", "sss");
Student s1 = new Student("cxy", "12345");
Student s2 = new Student("lz", "34567");
ArrayList<Student> students = new ArrayList<>();
ArrayList<Teacher> teachers = new ArrayList<>();
File file = new File("D:\\练习\\a.txt");
// 没有此文件就创建一个
if (!file.exists()){
file.createNewFile();
}
// 将对象加入到数组
students.add(s1);
students.add(s2);
teachers.add(t1);
teachers.add(t2);
// 序列化
// 输出
OutputStream outputStream = new FileOutputStream(file);
ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
// 将不同对象放在一起
objectOutputStream.writeObject(students);
objectOutputStream.writeObject(teachers);
// 关闭序列化
objectOutputStream.close();
}
}
4：序列化和反序列化
package com.File_practise;
import java.io.*;
import java.util.ArrayList;
public class Test2 {
public static void main(String[] args) throws IOException, ClassNotFoundException {
Student s1 = new Student("cxy", "12345");
Student s2 = new Student("lz", "12346");
Student s3 = new Student("mb", "12347");
Student s4 = new Student("hk", "12348");
ArrayList<Student> students = new ArrayList<>();
students.add(s1);
students.add(s2);
students.add(s3);
students.add(s4);
OutputStream fileOutputStream = new FileOutputStream("File/src/222.txt");
ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
objectOutputStream.writeObject(students);
objectOutputStream.close();
FileInputStream fileInputStream = new FileInputStream("File/src/222.txt");
ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
ArrayList<Student> student = (ArrayList<Student>) objectInputStream.readObject();
System.out.println(student);
}
}
1：serialVersionUID 常量
在对象进行序列化或反序列化操作的时候，要考虑 JDK 版本的问题。如果序列化的 JDK 版本和反序列化的 JDK 版本不统一，则可能造成异常。因此在序列化操作中引入了一个serialVersionUID 的常量来验证版本的一致性。在进行反序列化时，JVM 会把传来的字节流中的 serialVersionUID 与本地相应实体(类)的serialVersionUID 进行比较。如果相同就认为是一致的，可以进行反序列化，否则就会出现反序列化版本不一致的异常
Idea 配置自动生成序列号:
2：transient关键字--禁止序列化
如果不希望类中的属性被序列化，可以在声明属性之前加上transient关键字。如下所示，下面的代码修改自前面所用到的Person.java程序，在声明属性时，前面多加了一个transient关键字
private transient String name;
private transient int age;注意:
序列化细节:
1) 被序列化的类的内部的所有属性,必须是可序列化的
2) static,transient修饰的属性,不可以被序列化
3：总结
1:对于序列化的概述：Java序列化是指把Java对象转换为字节序列的过程;而Java反序列化是指把字节序列恢复为Java对象的过程。通过将对象序列化，可以方便的实现对象的传输及保存。
2：关键字：序列化--Serializable ，禁止序列化--transient
4、建议采纳
如有建议或者错误请私信我进行修改，感谢！！！
418
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
