Effective Java之考虑自定义的序列化模式(七十五)

为什么自定义序列化？

这里直接举一个书上的例子

public final class StringList implements Serializable {private int size = 0;private Entry head = null;private static class Entry implements Serializable {String data;Entry next;Entry previous;}....
}

我们知道，序列一个类，会同时序列化它的组件。
也就是说，如果我序列化了“B”对象， B是双向链表，它要序列化它的内部成员“A”和“C”对象，但是序列化“A”和“C”对象的时候，B同时也是它们的组件，也要序列化“B”～～～～～～～～
于是就进入了无穷的死循环中！！！

这时候，我们的需求很简单，对于每个对象的Entry，我只序列化一次就行了，不需要迭代序列化。
于是就有了transient关键字

public final class StringList implements Serializable {private static final long serialVersionUID = 1L;private transient int size = 0; //不会被序列化private transient Entry head = null;private static class Entry {String data;Entry next;Entry previous;}public final void add(String s) { ... }/*** Serialize this {@code StringList} instance* * @serialData The size of the list (the number of strings it contains)* is emitted ({@code int}), followed by all of its elements (each a * {@code String}), in the proper sequence.*/private void writeObject(ObjectOutputStream s) throws IOException {s.defaultWriteObject();s.writeInt(size);for(Entry e = head; e != null; e = e.next ) {s.writeObject(e.data);}}private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException {s.defaultReadObject();int num = s.readInt();for(int i=0; i < num; i++) {add((String)s.readObject());}}.....
}

标记为transient的不会自动序列化，这就防止默认序列化做出错误的事情，然后调用writeObject手动序列化transient字段，做自己认为正确的事。readObject同理。

注意⚠️：尽管StringList的所有域都是transient，但writeObject和readObject的首要任务仍是调用defaultXxxObject方法来序列化不带有transient的字段，这样可以极大的增强灵活性。因为万一以后加入了不带有transient的字段呢？

总结，自定义序列化目的就是做自己认为正确的事情，经典的例子有ArrayList和HashMap。

自定义序列化的例子

ArrayList

来看一下关键的实例域：

  private static final Object[] EMPTY_ELEMENTDATA = {};/*** Shared empty array instance used for default sized empty instances. We* distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when* first element is added.*/private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};/*** The array buffer into which the elements of the ArrayList are stored.* The capacity of the ArrayList is the length of this array buffer. Any* empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA* will be expanded to DEFAULT_CAPACITY when the first element is added.*/transient Object[] elementData; // non-private to simplify nested class access/*** The size of the ArrayList (the number of elements it contains).** @serial*/private int size;

这里定义空数组是为什么呢？
答案就在这里：Effective Java之返回零长度的数组或者集合，而不是null(四十三)

然后为什么transient Object[] elementData;
难道不应该初始化它的所有数组元素吗？
原因就是ArrayList实际上是动态数组，每次在放满以后自动增长设定的长度值，如果数组自动增长长度设为100，而实际elementData里面有可能有1个实际对象，其他都是null，默认的初始化会初始化99个null对象，这显然不合适！
所以，我们来欣赏一下它的writeObject方法：

    private void writeObject(java.io.ObjectOutputStream s)throws java.io.IOException{// Write out element count, and any hidden stuffint expectedModCount = modCount;s.defaultWriteObject();// Write out size as capacity for behavioural compatibility with clone()s.writeInt(size);// Write out all elements in the proper order.for (int i=0; i<size; i++) {s.writeObject(elementData[i]);}//prevent concurrent modificationif (modCount != expectedModCount) {throw new ConcurrentModificationException();}}

HashMap

   transient Node<K,V>[] table;

原因1

因为读写Map是根据Object.hashcode()来确定从table[i]读/写，而Object.hashcode()是native方法, 不同的JVM里可能是不一样的。比如向HashMap存一个键值对entry, key为字符串"hello", 在第一个java程序里, "hello"的hashcode()为1, 存入table【1】在另一个JVM程序里, "hello" 的hashcode()有可能就是2, 存入table【2】所以不管物理结构，序列化只负责把key，value送货上门，具体放在哪个table，序列化不需要理会。

原因2:

table 和 ArrayList的elementData  中存储的值数量是小于数组的大小的（数组扩容的原因），这个在元素越来越多的情况下更为明显。如果使用默认的序列化，那些没有元素的位置也会被存储，就会产生很多不必要的浪费。