ArrayList和LinkedList中的transient关键字和序列化

一、准备

在看ArrayList和LinkedList的源码的时候，发现ArrayList和LinkedList的一些成员变量变量被transient修饰了，有点不解，就查了一些资料。分享给大家。

ArrayList源码中的transient

LinkedList中的关键字

1.1 序列化与反序列化

序列化是java提供的一种将内存中的对象信息转化为二进制数组的方法，可以将数组保存和传输，然后使用原来的类模板恢复对象的信息。
转化后的二进制数组中包含以下信息：序列化版本，完整类名，serialVersionUID，各个属性的类型、名字和值、父类信息。

1.2 怎么实现序列化和反序列化

实现Serializable接口，使用ObjectOutputStream.writeObject(Object Object)写对象信息，使用ObjectInputStream.readObject()读对象信息。

package Aug_05;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class SerializebleTest implements Serializable{
    int num = 10;
    private static final long serialVersionUID = -1L;  //设置好serialVersionUID，减少反序列化失败的机率
    
    public static void main(String[] args) {
        try {
            //将对象序列化，并保存到本地文件中
            FileOutputStream fileOutputStream = new FileOutputStream("MySerialize");  //创建文件输出流
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);  //创建对象输出流
            SerializebleTest oldObject = new SerializebleTest();
            objectOutputStream.writeObject(oldObject);  //写对象信息
            objectOutputStream.flush();
            objectOutputStream.close();
            fileOutputStream.close();
            //从本地文件中读取序列化信息，恢复对象
            FileInputStream fileInputStream = new FileInputStream("MySerialize");
            ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
            SerializebleTest newObject = (SerializebleTest)objectInputStream.readObject();
            objectInputStream.close();
            fileInputStream.close();
            System.out.println("原始对象和恢复的对象是否是同一个对象:" + (newObject == oldObject));
            System.out.println("原始对象和恢复的对象中的值是否相同:" + (newObject.num == oldObject.num));
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

ObjectOutputStream.writeObject(ObjectA objectA)首先判断ObjectA有没有重写writeObject方法，如果有，反射调用ObjectA的writeObject方法完成序列化；否则，调用默认的序列化方法序列化。反序列化也一样

ObjectOutputStream的writeObject方法

1.2 transient关键字

被transient修饰的成员变量不会被序列化。
哪些情况下可以不用序列化呢？我认为有以下两种情况。
1.节省空间
比如，一个长方形类有成员变量：长、宽、面积。那么面积就不用序列化，因为面积可以根据其他两个计算出来，这样节省存储空间和传输空间。
2.持有对象的引用
比如，我们创建链表的结点如下。结点中持有前驱结点和后继结点的引用，引用就是对象在内存中的地址值。对于这样的结点形成的链表，我们序列化这个链表后，结点的前序和后继引用都失效了，因为内存地址变了。这种情况下我们需要重新连接链表。

    private static class Node<E> {
        E item;   // 数据
        Node<E> next;  //后继   
        Node<E> prev;  //前驱

        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }

二、分析

首先说以下结论：
1.ArrayList中将elementData修饰成transient是为了节省空间
2.LinkedList中将first和last修饰成transient是为了节省空间和重新连接链表。

2.1 ArrayList分析

查看源码我们知道ArrayList中使用数组transient Object[] elementData保存数据，当数组空间不够时，数组长度扩容为原来的1.5倍。那么数组中可能有没有使用的空间，比如elementData的长度时15，但是里面只装了11个元素，那么后面的4个元素都是空值。序列化的时候可以不把这4个元素序列化。
ArrayList中定义了writeObject和readObject方法，实现了自定义序列化。前面我们说了序列化的时候ObjectStream会判断类中有没有自定义序列化方法？如果有，使用自定义序列化方法：否则使用默认的序列化方法。
ArrayList自定义序列化方法如下

    private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException{
        // 先调用默认的序列化方法，将没有transient修饰的成员变量序列化
        int expectedModCount = modCount;
        s.defaultWriteObject();

        // 将元素容量序列化
        s.writeInt(size);

        // 将不为空的元素序列化
        for (int i=0; i<size; i++) {
            s.writeObject(elementData[i]);
        }

        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
    }

    private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        elementData = EMPTY_ELEMENTDATA;

        // 先调用默认的反序列化方法
        s.defaultReadObject();

        // 反序列化元素容量
        s.readInt(); // ignored

        if (size > 0) {
            // 检查容量，不过不够进行扩容
            ensureCapacityInternal(size);

            Object[] a = elementData;
            // 反序列化元素
            for (int i=0; i<size; i++) {
                a[i] = s.readObject();
            }
        }
    }

2.2 LinkedList分析

查看源码我们知道LinkedList中使用双向链表保存数据，结点中保存前驱和后继的引用。但是序列化之后前序结点和后继结点的地址都变了，我们应该连接新的结点。
下面看以下LinkedList是怎么自定义序列化的

    private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException {
        // 先调用默认的序列化方法
        s.defaultWriteObject();

        // 序列化容量
        s.writeInt(size);

        // 只把结点中的值序列化，前序和后继的引用不序列化
        for (Node<E> x = first; x != null; x = x.next)
            s.writeObject(x.item);
    }


    @SuppressWarnings("unchecked")
    private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        // 先调用默认的反序列化方法
        s.defaultReadObject();

        // 读容量
        int size = s.readInt();

        // 读取每一个结点保存的值，创建新结点，重新连接链表。
        for (int i = 0; i < size; i++)
            linkLast((E)s.readObject());
    }

我们看到了，LinkedList序列化的时候将链表按顺序拆分开来，仅序列化结点中保存的数据，反序列化的时候重新连接链表，保证了链表的有效性。