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 stuff
int 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 modification
if (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 中存储的值数量是小于数组的大小的（数组扩容的原因），这个在元素越来越多的情况下更为明显。如果使用默认的序列化，那些没有元素的位置也会被存储，就会产生很多不必要的浪费。