ArrayList的成员变量声明如下：
private transient Object[] elementData;// 存储ArrayList中的元素
这里会有几个问题：
- 为什么实现了Serializable接口却不想序列化这个属性。
- 最重要的存储数据的地方，不序列化这些元素值怎么办？
针对第一个问题：
因为elementData数组的大小实际上是大于等于实际存储元素个数的，如果直接采用默认的实例化的话，会将很多null序列化，这没必要。
针对第二个问题：
基于第一个问题，所以ArrayList中有一个private void 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);
// 序列化实际存储的元素
for (int i=0; i<size; i++) {
s.writeObject(elementData[i]);
}
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
}
至此引出一个问题：ArrayList的序列化到底是一个怎样的过程？
ArrayList的序列化
编写一个测试代码：
@Test
public void testSerializable() throws Exception {
ArrayList<String> list = new ArrayList<>();
list.add("string1");
list.add("string2");
// 序列化
File file = new File("d:/testSerializable");
FileOutputStream fs = new FileOutputStream(file);
ObjectOutputStream oos = new ObjectOutputStream(fs);
oos.writeObject(list);
fs.close();
oos.close();
// 反序列化
FileInputStream fi = new FileInputStream(file);
ObjectInputStream ois = new ObjectInputStream(fi);
ArrayList<String> readObject = (ArrayList) ois.readObject();
System.out.println(readObject);// 输出[string1, string2]，说明元素被序列化了
fi.close();
ois.close();
}
跟踪源码：
public final void writeObject(Object obj) throws IOException {
if (enableOverride) {// 用于为false，子类可以设置成true
writeObjectOverride(obj);
return;
}
try {
// 真正的逻辑
writeObject0(obj, false);
} catch (IOException ex) {
// 省略
}
}
private void writeObject0(Object obj, boolean unshared)
throws IOException
{
// 省略
try {
// 省略
// check for replacement object
Object orig = obj;
Class<?> cl = obj.getClass();
// 类序列化的描述符，里面包含了obj对应class的一些属性，如：是否有writeObject方法
ObjectStreamClass desc;
for (;;) {
// REMIND: skip this check for strings/arrays?
Class<?> repCl;
// 解析cl，获取实例
desc = ObjectStreamClass.lookup(cl, true);
if (!desc.hasWriteReplaceMethod() ||
(obj = desc.invokeWriteReplace(obj)) == null ||
(repCl = obj.getClass()) == cl)
{
break;
}
cl = repCl;
}
// 省略
// remaining cases
if (obj instanceof String) {
writeString((String) obj, unshared);
} else if (cl.isArray()) {
writeArray(obj, desc, unshared);
} else if (obj instanceof Enum) {
writeEnum((Enum<?>) obj, desc, unshared);
} else if (obj instanceof Serializable) {
// 实现了Serializable接口
writeOrdinaryObject(obj, desc, unshared);
} else {
if (extendedDebugInfo) {
throw new NotSerializableException(
cl.getName() + "\n" + debugInfoStack.toString());
} else {
throw new NotSerializableException(cl.getName());
}
}
} finally {
// 省略
}
}
// 调用writeOrdinaryObject -> writeSerialData
private void writeSerialData(Object obj, ObjectStreamClass desc)
throws IOException
{
ObjectStreamClass.ClassDataSlot[] slots = desc.getClassDataLayout();
for (int i = 0; i < slots.length; i++) {
ObjectStreamClass slotDesc = slots[i].desc;
// 从类序列化描述符ObjectStreamClass获取obj对应的类，是否有writeObject方法
if (slotDesc.hasWriteObjectMethod()) {
PutFieldImpl oldPut = curPut;
curPut = null;
SerialCallbackContext oldContext = curContext;
if (extendedDebugInfo) {
debugInfoStack.push(
"custom writeObject data (class \"" +
slotDesc.getName() + "\")");
}
try {
curContext = new SerialCallbackContext(obj, slotDesc);
bout.setBlockDataMode(true);
// 通过反射调用writeObject方法，对应ArrayList#writeObject
slotDesc.invokeWriteObject(obj, this);
bout.setBlockDataMode(false);
bout.writeByte(TC_ENDBLOCKDATA);
} finally {
}
curPut = oldPut;
} else {
// 序列化非transient属性
defaultWriteFields(obj, slotDesc);
}
}
}
总结
一切都比较明了，ArrayList中有writeObject方法是为了保证只序列化真实的元素，通过序列化时获取的ObjectStreamClass实例，如果需要反序列化的类（如ArrayList）包含writeObject方法，就通过反射调用。
