java中的序列化

1、概念

对象是由一个程序建立的，当程序被关掉，对象天然就消失了。为了可以使得对象可以保存还原，甚至经过网络等传输，就有了对象序列化这个概念。我是以为和持久化一个概念。java对象序列化最强大的一个方面是针对对象全部连环的引用都可以进行保存，而且可以反序列化。

2、实现

1.在java中对象序列化必需要继承Serializable接口，这个接口只是一个标识，标示可以进行序列化。该对象所引用的其余对象，以及其余对象所引用的其余其余对象也必须继承Serializble接口，否则序列化时会抛出异常java.io.NotSerializableException。还要生成serialVersionUID，这个ID是根据属性和方法生成的。表示版本号。若是反序列化的时候，版本号不一致就会抛出异常。

2.序列化的实现很是简单：首先要有一个ObjectOutputStream 对象 ，而后调用writeObject(Object objec)方法就好了。反序列化须要有一个ObjectInputStream对象，而后调用readObject()方法。再强行转换成你要的类就好了。

3、demo

public class Wheel implements Serializable{
	private static final long serialVersionUID = 5801095499370035805L;
	private String id;
	private String brand;
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getBrand() {
		return brand;
	}
	public void setBrand(String brand) {
		this.brand = brand;
	}
}

public class Car implements Serializable{
	private static final long serialVersionUID = 5765553644244739065L;
	private Wheel[] wheel ;
	
	private String brand;
	
	private int price ;
	private String ow;
	public Wheel[] getWheel(  ) {
		return wheel;
	}
	public void setWheel(Wheel[] wheel) {
		this.wheel = wheel;
	}
	public String getBrand() {
		return brand;
	}
	public void setBrand(String brand) {
		this.brand = brand;
	}
	public int getPrice() {
		return price;
	}
	
	public void setPrice(int price) {
		this.price = price;
	}
}

public static void main(String[] args) throws IOException, ClassNotFoundException{
		FileOutputStream fos = new FileOutputStream(new File("/home/liubin/test.txt"));
		ObjectOutputStream oos = new ObjectOutputStream(fos);
		Wheel[] wheel = new Wheel[4];
		wheel[0] = new Wheel();
		wheel[0].setBrand("JIATONG");
		wheel[0].setId("00001");
		wheel[1] = new Wheel();
		wheel[1].setBrand("JIATONG");
		wheel[1].setId("00002");
		wheel[2] = new Wheel();
		wheel[2].setBrand("JIATONG");
		wheel[2].setId("00003");
		wheel[3] = new Wheel();
		wheel[3].setBrand("JIATONG");
		wheel[3].setId("00004");
		
		Car car = new Car();
		car.setPrice(800000);
		car.setBrand("BMW");
		car.setWheel(wheel);
		oos.writeObject(car);
		oos.flush();
		oos.close();
		
		//反序列化
		FileInputStream fis = new FileInputStream(new File("/home/liubin/test.txt"));
		ObjectInputStream ois = new ObjectInputStream(fis);
		Object object = ois.readObject();
		ois.close();
		Car cars = (Car)object;
		System.out.println(car);
		System.out.println(cars);
		System.out.println(car == cars);
	}
}

最终Car对象写入到文件中，而后可以反序列化。

关于Externalizable这个类是继承了Serializable，可是能够实现对序列化的一些控制，就很少说了。还有一点就是transient这个关键字修饰的属性或者是方式是不参与序列化的。此外使用static修饰的属性也是不参与序列化的。