Difference between serialization of Vector and ArrayList

[Girish K Gupta]

Hi all

Could anyone please throw some light on why the serialization of Vector and ArrayList is handled differently?
The object element array used internally in ArrayList is marked transient but not in Vector. Vector uses default Serialization approach accept making the writeObject method synchronized while ArryList manually writes and reads every element.

Regards.

[Jesper de Jong]

I've looked at the source code of the ArrayList.writeObject() method.

I think the reason why it has its own writeObject() method rather than relying on the default (built-in) serialization is because it needs to check for modifications in the method, throwing a ConcurrentModificationException if the ArrayList was modified by another thread while it was busy writing its contents to a stream.

[Girish K Gupta]

Thanks for your reply Jesper. I understand the point that for ArrayList ConcurrentModificationException has to be thrown in case of modification while writing the object.
In ArrayList writeObject method looks like:

	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();
        	}

While for Vector it is:

 	   private synchronized void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException
    	{
		s.defaultWriteObject();
    	}

What I want to understand is why ArrayList separately writes each element which doesn't happen for Vector.
Could we not have the following code for ArrayList:

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

>

[Jelle Klap]

That won't work for ArrayList, because its internal Object array is declared transient, and defaultwriteObject() doesn't write transient fields to the stream.
Writing the array's size and actual contents instead of the entire array itself is slightly more efficiënt, because the array would add it's own overhead to the serialization process.

[Girish K Gupta]

Thanks Jelle. I didn't know about the following:

Writing the array's size and actual contents instead of the entire array itself is slightly more efficiënt, because the array would add it's own overhead to the serialization process

Do you mind sharing the source of this information? Would do some study

[Jelle Klap]

Why not just give it a try?
Initialize an Object array, and stuff one String into it. Serialize the int returned by the array's length property, using an ObjectOutpuStream#write, followed by the String instance using ObjectOutpuStream#writeObject() to a file. Then serialize the entire array, using ObjectOutpuStream#writeObject() to another file. You should be able to get a pretty good impression of the difference between these two files using any HEX editor.

[Girish K Gupta]

Yes Jelle I noticed the difference. Tried serializing object of an ArrayList and a Vector filled with same objects.
In my case serialized ArrayList object took 230 bytes while serialized Vector object took 335 bytes of memory.

[Jelle Klap]

Ok, but that doesn't really clearly represent the difference between serializing an entire array versus serializing the size of the array an all its elements in order.