ArrayList的成员变量声明如下：

private transient Object[] elementData;// 存储ArrayList中的元素

这里会有几个问题：

1. 为什么实现了Serializable接口却不想序列化这个属性。
2. 最重要的存储数据的地方，不序列化这些元素值怎么办？

针对第一个问题：
因为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方法，就通过反射调用。