java基础-序列化与反序列化

1.Java序列化与反序列化

Java序列化是指把Java对象转换为字节序列的过程；而Java反序列化是指把字节序列恢复为Java对象的过程。

Java序列化的好处：

其好处一是实现了数据的持久化，通过序列化可以把数据永久地保存到硬盘上（通常存放在文件里），二是，利用序列化实现远程通信，即在网络上传送对象的字节序列。

2.实现序列化与反序列化的步骤

1).要求：
Serializable或Externalizable接口的类的对象才能被序列化，否则抛出异常。
2).JDK类库中序列化API
java.io.ObjectOutputStream：表示对象输出流
它的writeObject(Object obj)方法可以对参数指定的obj对象进行序列化，把得到的字节序列写到一个目标输出流中。
java.io.ObjectInputStream：表示对象输入流
它的readObject()方法源输入流中读取字节序列，再把它们反序列化成为一个对象，并将其返回。
3).序列化与反序列化的示例
Student类

public class Student implements Serializable  
{  
 private String name;  
 private char sex;  
 private int year;  
 private double gpa;  

 public Student()  
 {  

 }  
 public Student(String name,char sex,int year,double gpa)  
 {  
  this.name = name;  
  this.sex = sex;  
  this.year = year;  
  this.gpa = gpa;  
 } 
 //set   get......
 } 

把Student类的对象序列化到文件O:\Java\com\jieke\io\student.txt，并从该文件中反序列化，向console显示结果。代码如下：

public class UseStudent  
{  
 public static void main(String[] args)  
 {  
  Student st = new Student("Tom",'M',20,3.6);  
  File file = new File("O:\\Java\\com\\jieke\\io\\student.txt");  
  try  
  {  
   file.createNewFile();  
  }  
  catch(IOException e)  
  {  
   e.printStackTrace();  
  }  
  try  
  {  
   //Student对象序列化过程  
   FileOutputStream fos = new FileOutputStream(file);  
   ObjectOutputStream oos = new ObjectOutputStream(fos);  
   oos.writeObject(st);  
   oos.flush();  
   oos.close();  
   fos.close();  

   //Student对象反序列化过程  
   FileInputStream fis = new FileInputStream(file);  
   ObjectInputStream ois = new ObjectInputStream(fis);  
   Student st1 = (Student) ois.readObject();  
   System.out.println("name = " + st1.getName());  
   System.out.println("sex = " + st1.getSex());  
   System.out.println("year = " + st1.getYear());  
   System.out.println("gpa = " + st1.getGpa());  
   ois.close();  
   fis.close();  
  }  
  catch(ClassNotFoundException e)  
  {  
   e.printStackTrace();  
  }  
  catch (IOException e)  
  {  
   e.printStackTrace();  
  }               
 }  
}  

3. transient关键字

当某个字段被声明为transient后，默认序列化机制就会忽略该字段。此处将Person类中的age字段声明为transient，如下所示，

public class Student implements Serializable {  
    ...  
    transient private Integer age = null;  
    ...  
} 

再执行SimpleSerial应用程序，会有如下输出：

arg constructor  
[John, null, MALE] 

可见，age字段未被序列化。

4.Serializable的作用

为什么一个类实现了Serializable接口，它就可以被序列化呢？在上节的示例中，使用ObjectOutputStream来持久化对象，在该类中有如下代码：

private void writeObject0(Object obj, boolean unshared) throws IOException {  
      ...
    if (obj instanceof String) {  
        writeString((String) obj, unshared);  
    } else if (cl.isArray()) {  
        writeArray(obj, desc, unshared);  
    } else if (obj instanceof Enum) {  
        writeEnum((Enum) obj, desc, unshared);  
    } else if (obj instanceof Serializable) {  
        writeOrdinaryObject(obj, desc, unshared);  
    } else {  
        if (extendedDebugInfo) {  
            throw new NotSerializableException(cl.getName() + "\n" 
                    + debugInfoStack.toString());  
        } else {  
            throw new NotSerializableException(cl.getName());  
        }  
    }  
    ...  
} 

从上述代码可知，如果被写对象的类型是String，或数组，或Enum，或Serializable，那么就可以对该对象进行序列化，否则将抛出NotSerializableException。

参考：http://blog.csdn.net/wangloveall/article/details/7992448/
http://developer.51cto.com/art/201202/317181.htm