对象序列化和反序列化是怎么回事

对象序列化和反序列化是怎么回事关键字: serializable 序列化 反序列化 入门　　之前看公司RMI服务里多数类都实现了序列化接口(implements Serializable)，但确怎么也不知道序列化是怎么一回事，上网查了很多序列化的概念，但那些概念太抽象了，还是无法理解，直到今天，终于有了一 些自己的理解，在这里写出来，希望对与我存在同样困扰的朋友们能有所帮助。
我们都知道，当我们new一个对象的时候，Java就会在内存中创建一个相应的对象供我们后续使用。如果我们把这个Java程序关掉的话，那么这个对象也就随着我们程序的关闭而消失，如何才能在这种情况下继续保存这个对象呢？这就是Java序列化要做的事情。简单地说，Java对象列化就是要把内存中的Java对象保存下来(持久化)，以便可以在网络上传输或今后继续使用这个对象中的数据。
那么对象序列化到底做了哪些事呢？其实很简单，一个对象对于我们来说的意义其实就是对象里保存的那些数据，序列化就是把这些数据转换成二进制 表示的对象流，你可以把它通过网络传输到远程，当然，也可以把这些信息保存在本地的文件里。下面给出一个最简单的Java的序列化与反序列化的例子，看懂 这个例子，相信你应该也能跟我一样，大概理解这是怎么一回事了。
首先是一个Peraon类：
Person.java
Java代码

1. package com.lanber.serial;  
2.   
3. import java.io.Serializable;  
4.   
5. public class Person implements Serializable {  
6.     private String name;  
7.     private int age;  
8.     private String sex;  
9.     private String nationality;  
10.   
11.     public Person(String _name, int _age, String _sex, String _nationality) {  
12.         this.name = _name;  
13.         this.age = _age;  
14.         this.sex = _sex;  
15.         this.nationality = _nationality;  
16.      }  
17.   
18.     public String toString() {  
19.         return "Name:" + name + "\nAge:" + age + "\nSex:" + sex  
20.                  + "\nNationality:" + nationality + "\n\n";  
21.      }  
22. }  

package com.lanber.serial; import java.io.Serializable; public class Person implements Serializable { private String name; private int age; private String sex; private String nationality; public Person(String _name, int _age, String _sex, String _nationality) { this.name = _name; this.age = _age; this.sex = _sex; this.nationality = _nationality; } public String toString() { return "Name:" + name + "\nAge:" + age + "\nSex:" + sex + "\nNationality:" + nationality + "\n\n"; } }
而后我们要实例化一个Person对象，把我们实例化出来的这个对象序列化，并把序列化后的对象流保存到文件中去：
WritePerson.java
Java代码

1. package com.lanber.serial;  
2.   
3. import java.io.*;  
4.   
5. public class WritePerson {  
6.   
7.     public static void main(String[] args) {  
8.         try {  
9.              ObjectOutputStream oos = new ObjectOutputStream(  
10.                     new FileOutputStream("Person.tmp"));  
11.              Person obj = new Person("Tony", 25, "Female", "han");  
12.              System.out.println("将Person对象写入到文件Person.tmp中...");  
13.              oos.writeObject(obj);  
14.              oos.close();  
15.              System.out.println("完成！");  
16.          } catch (Exception e) {  
17.              System.out.println(e);  
18.          }  
19.   
20.      }  
21. }  

package com.lanber.serial; import java.io.*; public class WritePerson { public static void main(String[] args) { try { ObjectOutputStream oos = new ObjectOutputStream( new FileOutputStream("Person.tmp")); Person obj = new Person("Tony", 25, "Female", "han"); System.out.println("将Person对象写入到文件Person.tmp中..."); oos.writeObject(obj); oos.close(); System.out.println("完成！"); } catch (Exception e) { System.out.println(e); } } }
这样，我们就把序列化后的二进制对象流保存到Person.tmp的文件中去了(特别要注意这里的oos.writeObject()方法， 这个方法就是实现把obj对象序列化的方法)。你可以打开生成的这个文件查看，不过我们是看不懂这里面的信息的，因为这是二进制数据啊。
那我们要怎么才能看懂这些二进制数据呢？这就要用到我们的反序列化了。反序列化就是要把序列化后的二进制数据反向解析成可以正常使用的Java对象。现在让我们来把刚才的那个对象反序列化一下吧：
ReadPerson.java
Java代码

1. package com.lanber.serial;  
2.   
3. import java.io.*;  
4.   
5. public class ReadPerson {  
6.     public static void main(String[] args) {  
7.          Person obj = null;  
8.         try {  
9.              ObjectInputStream ois = new ObjectInputStream(new FileInputStream(  
10.                     "Person.tmp"));  
11.              obj = (Person) ois.readObject();  
12.              System.out.println(obj);  
13.              ois.close();  
14.          } catch (Exception e) {  
15.              System.out.println(e);  
16.          }  
17.      }  
18.   
19. }  

package com.lanber.serial; import java.io.*; public class ReadPerson { public static void main(String[] args) { Person obj = null; try { ObjectInputStream ois = new ObjectInputStream(new FileInputStream( "Person.tmp")); obj = (Person) ois.readObject(); System.out.println(obj); ois.close(); } catch (Exception e) { System.out.println(e); } } }
要注意一下这个语句：
Java代码

1. obj = (Person) ois.readObject();  

obj = (Person) ois.readObject();
就是通过这个语句把序列化后的对象流反序列化成正常的Java对象的。
以上就是本人对Java对象序列化与反序列化的理解，纯属入门级别的理解，若有不正之处，还望javaeye的高手们多多批评指正，不胜感激!