ArrayList的remove、序列化（二）

对象的序列化作为一种存储对象为字节序列的方式，可以将对象保存到本地文件或者通过网络进行传输，是RMI对象或参数传递的基础。

对象的序列化会在输出流中保留一个序列化编号，当再次通过该对象输出流对同一个对象进行序列化时，只会存储一个编号，而不会存储整个对象。这种方式虽然可以保证在执行反序列化时，得到的仍然是同一个对象，但是同样使得第一次序列化后，对对象执行的修改在后续序列化中得不到保存，当然前提是使用同一个对象输出流，如果新建了输出流，则理所应当存储对象。

示例：

class t2{  
    public static void main(String[] args){  
        Person p=new Person("xiaoming",18);
		ObjectOutputStream os=null;
		ObjectInputStream oi=null;
		try{
			os=new ObjectOutputStream(new FileOutputStream("t1.txt"));
			os.writeObject(p);//第一次序列化
			p.name="zhangsan";//方便起见，属性直接为public
			os.writeObject(p);//第二次序列化
			oi=new ObjectInputStream(new FileInputStream("t1.txt"));
			
			Person p1=(Person)oi.readObject();
			System.out.println("p1:"+p1);
			Person p2=(Person)oi.readObject();
			System.out.println("p2:"+p2);
			System.out.println("p2==p1:"+(p2==p1));
		}catch(Exception e){
			e.printStackTrace();
		}finally{
			try{
				if(os!=null){
					os.close();
				}
			}catch(IOException e){
				e.printStackTrace();
			}
		}
	}  
}  

class Person implements Serializable{
	public String name;
	public int age;
	public Person(String name,int age){
		this.name=name;
		this.age=age;
	}
	public String toString(){
		return "name:"+name+",age:"+age;
	}
}
/*
*输出结果为：
*p1:name:xiaoming,age:18
*p2:name:xiaoming,age:18
*p2==p1:true
*/

对象的修改没有得到保存。

这里多说一句，待执行序列化的对象，其类必须实现了序列化接口，并且其内部属性，如果没有显式加transient修饰，则属性的类也必须实现序列化接口，该示例String，Number类都实现了序列化接口，否则会抛出NotSerializableException。

关于ArrayList的序列化操作

ArrayList的属性表示为：

private static final long serialVersionUID = 8683452581122892189L;
private transient Object[] elementData;
private int size;

其中将elementData元素数组加以transient修饰，表示在ArrayList对象的序列化时，忽略数组的序列化。在ArrayList内部存在writeObject方法

private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException{
        // Write out element count, and any hidden stuff
        int expectedModCount = modCount;
        s.defaultWriteObject();

        // Write out array length
        s.writeInt(elementData.length);

        // Write out all elements in the proper order.
        for (int i=0; i<size; i++)
            s.writeObject(elementData[i]);

        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }

    }

意思也就是在ArrayList对象序列化时，关于elementData元素数组部分的序列化的控制权，由ObjectOutputStream转移给ArrayList对象本身来控制。

elementData是一个Object[]类型的数组，数组的容量大小是动态扩展的，最初为10，size反映的是有效表示的元素个数，从代码中可以看到，对于elementData数组的元素，进行序列化的只是有效的数据元素，而非elementData数组的全部容量。

示例：

class t2{  
    public static void main(String[] args){  
		T_list<String> list=new T_list(10);
		list.add("first");
		list.add("second");
		ObjectOutputStream os=null;
		ObjectInputStream oi=null;
		try{
			os=new ObjectOutputStream(new FileOutputStream("t1.txt"));

			os.writeObject(list);
			
			oi=new ObjectInputStream(new FileInputStream("t1.txt"));

			T_list<String> list1=(T_list<String>)oi.readObject();
			
		}catch(Exception e){
			e.printStackTrace();
		}finally{
			try{
				if(os!=null){
					os.close();
				}
			}catch(IOException e){
				e.printStackTrace();
			}
		}
	}  
}  

class T_list<E> implements Serializable{
	private transient Object[] elementData;
	private int size;
	public T_list(int capacity){
		this.elementData=new Object[capacity];
		size=0;
	}
	public void add(E e){
		if(size==elementData.length){
			throw new IndexOutOfBoundsException();
		}
		elementData[size++]=e;
	}
	public int getElementsLength(){
		return elementData.length;
	}
	private void writeObject(java.io.ObjectOutputStream s) throws Exception{
        // Write out element count, and any hidden stuff
       
        s.defaultWriteObject();

        // Write out array length
        s.writeInt(elementData.length);

        // Write out all elements in the proper order.
        for (int i=0; i<size; i++){
            s.writeObject(elementData[i]);
		}
    }
	private void readObject(java.io.ObjectInputStream s) throws Exception{
        // Read in size, and any hidden stuff
        s.defaultReadObject();

        // Read in array length and allocate array
        int arrayLength = s.readInt();
        Object[] a = elementData = new Object[arrayLength];

        // Read in all elements in the proper order.
        for (int i=0; i<size; i++){
            a[i] = s.readObject();
		}
    }
}

总结：

对象的序列化会在输出流中保存一个对象的序列化编号，防止重复对一个对象进行多次保存，例如多个对象包含对同一个对象的引用，在序列化时只保存一次该引用对象。也避免了反序列化时，对同一个引用生成多个不同的对象。但是造成了在一次序列化之后，对象上的修改不能在再次序列化时保存。

ArrayList的elementData元素数组使用transient修饰，在ArrayList对象进行序列化时，将忽略该部分，由ArrayList对象控制对elementData的序列化和反序列化，依次保证只对数组有效元素部分进行序列化。