java_序列化

序列化

 

一、序列化和反序列化的定义：

　1.序列化就是指把对象转换为字节序列的过程

      　反序列化就是指把字节序列恢复为对象的过程。

　　2.序列化最重要的作用：在传递和保存对象时.保证对象的完整性和可传递性。对象转换为有序字节流,以便在网络上传输或者保存在本地文件中。

      　反序列化的最重要的作用：根据字节流中保存的对象状态及描述信息，通过反序列化重建对象。

 

二、序列化操作：

　1.一个对象要想序列化，必须满足两个条件:

• 该类必须实现java.io.Serializable 接口，Serializable 是一个标记接口，不实现此接口的类将不会使任何状态序列化或反序列化，会抛出NotSerializableException 。

• 该类的所有属性必须是可序列化的。如果有一个属性不需要可序列化的，则该属性必须注明是瞬态的，使用transient 关键字修饰。

　　

　　2.ObjectOutputStream类：

　　　　2.1 序列化：

• 定义一个Adress类：

 1 package demo1;
 2 
 3 import java.io.Serializable;
 4 
 5 public class Adress implements Serializable {
 6     private String address;
 7     private String street;
 8 
 9     public String getAddress() {
10         return address;
11     }
12 
13     public void setAddress(String address) {
14         this.address = address;
15     }
16 
17     public String getStreet() {
18         return street;
19     }
20 
21     public void setStreet(String street) {
22         this.street = street;
23     }
24 
25     public Adress() {
26     }
27 
28     public Adress(String address, String street) {
29         this.address = address;
30         this.street = street;
31     }
32 
33     @Override
34     public String toString() {
35         return "Adress{" +
36                 "address='" + address + '\'' +
37                 ", street='" + street + '\'' +
38                 '}';
39     }
40 }

 

• 定义一个Student类：

 1 package demo1;
 2 
 3 import java.io.Serializable;
 4 
 5 public class Student implements Serializable {
 6     private String name;
 7     private int age;
 8     private Adress address;
 9 
10     public Student() {
11     }
12 
13     public Student(String name, int age, Adress address) {
14         this.name = name;
15         this.age = age;
16         this.address = address;
17     }
18 
19     @Override
20     public String toString() {
21         return "Student{" +
22                 "name='" + name + '\'' +
23                 ", age=" + age +
24                 ", address=" + address +
25                 '}';
26     }
27 
28     public String getName() {
29         return name;
30     }
31 
32     public void setName(String name) {
33         this.name = name;
34     }
35 
36     public int getAge() {
37         return age;
38     }
39 
40     public void setAge(int age) {
41         this.age = age;
42     }
43 
44     public Adress getAddress() {
45         return address;
46     }
47 
48     public void setAddress(Adress address) {
49         this.address = address;
50     }
51 }

 

• 应用：

 1 package demo1;
 2 
 3 import java.io.*;
 4 
 5 public class Demo1 {
 6     public static void main(String[] args) {
 7         //序列化
 8         Student studen=new Student("小明",18,new Adress("湖南省长沙市岳麓区","含浦大道"));
 9 
10         File file=new File("student.bat");
11         try {
12             FileOutputStream fos=new FileOutputStream(file);
　　　　　　　　　// 创建序列化流对象
13             ObjectOutputStream oos=new ObjectOutputStream(fos);
　　　　　　　　　// 写出对象
14             oos.writeObject(studen);
　　　　　　　　　// 刷新
15             oos.flush();
　　　　　　　　　// 释放资源
16             fos.close();
17             oos.close();
18             System.out.println("序列化成功！");
19         } catch (FileNotFoundException e) {
20             e.printStackTrace();
21         } catch (IOException e) {
22             e.printStackTrace();
23         }
24 
25     }
26 }

 

• 运行效果图：

 

 

 

 

 

 

　　　　2.2 反序列化：

• 代码：

 1 package demo1;
 2 
 3 import java.io.*;
 4 
 5 public class Demo2 {
 6     public static void main(String[] args) {
 7         //反序列化
 8         File file = new File("student.bat");
 9         try {
10             FileInputStream fis=new FileInputStream(file);
11             ObjectInputStream ois=new ObjectInputStream(fis);
12             Student student=(Student) ois.readObject();
13             fis.close();
14             ois.close();
15             System.out.println(student);
16             System.out.println("反序列化成功！");
17 
18         } catch (FileNotFoundException e) {
19             e.printStackTrace();
20         } catch (IOException e) {
21             e.printStackTrace();
22         } catch (ClassNotFoundException e) {
23             e.printStackTrace();
24         }
25     }
26 }

 

• 运行效果图：