串行化和反串行化

串行化是指存储和获取磁盘文件、内存或其他地方中的对象。在串行化时，所有的实例数据都保存到存储介质上，
在取消串行化时，对象会被还原，且不能与其原实例区别开来。只需给类添加Serializable属性，就可以实现串行化实
的成员。

反串行化是串行化的逆过程，数据从存储介质中读取出来，并赋给类的实例变量。

串行化/序列化：将java对象转换成某种格式（JVM定义的）的字节数组
串行化使用场景：
将对象用户网络间传输或者是本地化储存。

反串行化：将字节数组恢复成java对象。

package com.yongjun.io;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import org.junit.Test;
 class ObejctSerializeDemo {
 /**
  * 串行化方法javabean
  * @throws Exception
  */
 @Test
 public void serializePerson() throws Exception {
Person p=new Person("tom",12);  
System.out.println(p);
FileOutputStream fos=new FileOutputStream("e:/p.data");
ObjectOutputStream oos=new ObjectOutputStream(fos);
oos.writeObject(p);
oos.close();
fos.close();
 }
 /**
  * 反串行化方法javabean
  * @throws Exception
  */
 @Test
 public void DeSerializePerson() throws Exception {
FileInputStream fis=new FileInputStream("e:/p.data");
ObjectInputStream ois=new ObjectInputStream(fis);
Person p=(Person)ois.readObject();
ois.close();
fis.close();
System.out.println(p.getName()+p.getMarried());
 }
}

串行化和反串行化实现深度复制：

/**
 * 深度复制，复制的是整个对象
 * @author Frenzy Fan
 *
 */
public class DeepCopyDemo {
 @Test
public void Seria() throws Exception, Exception {
 Person p=new Person();
 Son s=new Son();
 Dog d=new Dog();
 //设置关联关系
 s.setPerson(p);
 d.setSon=(s);
 //串行化，串行到磁盘了，如果很大，读取很慢，所以要穿行到内存字节数组
 ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("e:/kk.data"));
 oos.writeObject(d);
 oos.close();
}
 /**
  * 使用byteArrayInputStream+ByteArrayOutputStream实现对象的深度复制
  * @throws Exception 
  */
 public void deeplyCopyInBAOS() throws Exception {
  Person p=new Person();
  Son s=new Son();
  Dog d=new Dog();
  //设置关联  
  s.setPerson(p);
  d.setSon(s);
  //串行化过程到内存中
  ByteArrayOutputStream baos=new ByteArrayOutputStream();
  ObjectOutputStream oos=new ObjectOutputStream(baos);
  oos.writeObject(d);
  oos.close();
  baos.close();
  //提取内存中的数据
  byte []bytes=baos.toByteArray();
  //反串行化过程
  ByteArrayInputStream bais=new ByteArrayInputStream(bytes);
  ObjectInputStream ois=new ObjectInputStream(bais);
  d=(Dog)ois.readObject();
  ois.close();
  bais.close();
  System.out.println(d.getSon().getName()); 
 }
 @Test
 /**
  * 反串行化
  */
 public void deSeria()throws Exception{
  ObjectInputStream oos=new ObjectInputStream(new FileInputStream("e:/kk.data"));
 Dog d=(Dog)oos.readObject();
 oos.close();
 System.out.println(d.getSon());
 } 
 /**
  * 持续写入数据
  */
 @Test
 public void continusWrite()throws Exception{
  Person p=new Person();
  p.setName("tom");
  Son s=new Son();
  s.setName("jerry");
  Dog d=new Dog();
  d.setName("yellow");
  //串行
  ByteArrayOutputStream baos=new ByteArrayOutputStream();
  ObjectOutputStream oos=new ObjectOutputStream(baos);
  oos.writeObject(p);
  oos.writeObject(s);
  oos.writeObject(d);
  oos.close();
  baos.close();
  byte[]bytes=baos.toByteArray();
  //反串行
  ObjectInputStream ois=new ObjectInputStream(new ByteArrayInputStream(bytes));
 Person pe=(Person)ois.readObject();
 Son s2=(Son)ois.readObject();
 Dog d2=(Dog)ois.readObject();
 ois.close();
 }
}
class Person implements Serializable {
 private String name;
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
}
class Son implements Serializable{
 private String name;
 //transient临时的，暂时的。
 private  transient Person person;
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public Person getPerson() {
  return person;
 }
 public void setPerson(Person person) {
  this.person = person;
 } 
}
class Dog implements Serializable{
 public Son setSon;
 private String name;
 private Son son;
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public Son getSon() {
  return son;
 }
 public void setSon(Son son) {
  this.son = son;
 }
}