轉自https://my.oschina.net/u/1027043/blog/1627441

在分析HashMap和ArrayList的源碼時，我們會發現裏面存儲數據的數組都是用transient關鍵字修飾的，如下：

HashMap裏面的：

 transient Node<K,V>[] table;

ArrayList裏面的：

 transient Object[] elementData

既然用transient修飾，那就說明這個數組是不會被序列化的，那麽同時我們發現了這兩個集合都自定義了獨自的序列化方式：

先看HashMap自定義的序列化的代碼：

//1
    private void writeObject(java.io.ObjectOutputStream s)
        throws IOException {
        int buckets = capacity();
        // Write out the threshold, loadfactor, and any hidden stuff
        s.defaultWriteObject();
        s.writeInt(buckets);
        s.writeInt(size);
        internalWriteEntries(s);
    }
//2    
 public void internalWriteEntries(java.io.ObjectOutputStream s) throws IOException {
        Node<K,V>[] tab;
        if (size > 0 && (tab = table) != null) {
            for (int i = 0; i < tab.length; ++i) {
                for (Node<K,V> e = tab[i]; e != null; e = e.next) {
                    s.writeObject(e.key);
                    s.writeObject(e.value);
                }
            }
        }
    } 
    
 

再看HashMap自定義的反序列化的代碼：

//1
   private void readObject(java.io.ObjectInputStream s)
        throws IOException, ClassNotFoundException {
        // Read in the threshold (ignored), loadfactor, and any hidden stuff
        s.defaultReadObject();
        reinitialize();
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new InvalidObjectException("Illegal load factor: " +
                                             loadFactor);
        s.readInt();                // Read and ignore number of buckets
        int mappings = s.readInt(); // Read number of mappings (size)
        if (mappings < 0)
            throw new InvalidObjectException("Illegal mappings count: " +
                                             mappings);
        else if (mappings > 0) { // (if zero, use defaults)
            // Size the table using given load factor only if within
            // range of 0.25...4.0
            float lf = Math.min(Math.max(0.25f, loadFactor), 4.0f);
            float fc = (float)mappings / lf + 1.0f;
            int cap = ((fc < DEFAULT_INITIAL_CAPACITY) ?
                       DEFAULT_INITIAL_CAPACITY :
                       (fc >= MAXIMUM_CAPACITY) ?
                       MAXIMUM_CAPACITY :
                       tableSizeFor((int)fc));
            float ft = (float)cap * lf;
            threshold = ((cap < MAXIMUM_CAPACITY && ft < MAXIMUM_CAPACITY) ?
                         (int)ft : Integer.MAX_VALUE);
            @SuppressWarnings({"rawtypes","unchecked"})
                Node<K,V>[] tab = (Node<K,V>[])new Node[cap];
            table = tab;

            // Read the keys and values, and put the mappings in the HashMap
            for (int i = 0; i < mappings; i++) {
                @SuppressWarnings("unchecked")
                    K key = (K) s.readObject();
                @SuppressWarnings("unchecked")
                    V value = (V) s.readObject();
                putVal(hash(key), key, value, false, false);
            }
        }
    }
    
    
    
 

這裏面我們看到HashMap的源碼裏面自定義了序列化和反序列化的方法，序列化方法主要是把當前HashMap的buckets數量，size和裏面的k,v對一一給寫到了對象輸出流裏面，然後在反序列化的時候，再從流裏面一一的解析出來，然後又重新恢復出了HashMap的整個數據結構。

接著我們看ArrayList裏面自定義的序列化的實現：

    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]);
        }

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

然後反序列化的實現：

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

        // Read in size, and any hidden stuff
        s.defaultReadObject();

        // Read in capacity
        s.readInt(); // ignored

        if (size > 0) {
            // be like clone(), allocate array based upon size not capacity
            ensureCapacityInternal(size);

            Object[] a = elementData;
            // Read in all elements in the proper order.
            for (int i=0; i<size; i++) {
                a[i] = s.readObject();
            }
        }
    }

ArrayList裏面也是把其size和裏面不為null的數據給寫到流裏面，然後在反序列化的時候重新使用數據把數據結構恢復出來。

那麽問題來了，為什麽他們明明都實現了Serializable接口，已經具備了自動序列化的功能，為啥還要重新實現序列化和反序列化的方法呢？

（1）HashMap中實現序列化和反序列化的原因：

在HashMap要定義自己的序列化和反序列化實現，有一個重要的因素是因為hashCode方法是用native修飾符修飾的，也就是用它跟jvm的運行環境有關，Object類中的hashCode源碼如下：

 public native int hashCode();

也就是說不同的jvm虛擬機對於同一個key產生的hashCode可能是不一樣的，所以數據的內存分布可能不相等了，舉個例子，現在有兩個jvm虛擬機分別是A和B，他們對同一個字符串x產生的hashCode不一樣：

所以導致：

在A的jvm中它的通過hashCode計算它在table數組中的位置是3

在B的jvm中它的通過hashCode計算它在table數組中的位置是5

這個時候如果我們在A的jvm中按照默認的序列化方式，那麽位置屬性3就會被寫入到字節流裏面，然後通過B的jvm來反序列化，同樣會把這條數據放在table數組中3的位置，然後我們在B的jvm中get數據，由於它對key的hashCode和A不一樣，所以它會從5的位置取值，這樣以來就會讀取不到數據。

如何解決這個問題，首先導致上面問題的主要原因在於因為hashCode的不一樣從而可能導致內存分布不一樣，所以只要在序列化的時候把跟hashCode有關的因素比如上面的位置屬性給排除掉，就可以解決這個問題。

最簡單的辦法就是在A的jvm把數據給序列化進字節流，而不是一刀切把數組給序列化，之後在B的jvm中反序列化時根據數據重新生成table的內存分布，這樣就來就完美解決了這個問題。

（2）ArrayList中實現序列化和反序列化的原因：

在ArrayList中，我們知道數組的長度會隨著數據的插入而不斷的動態擴容，每次擴容都需要增加原數組一半的長度，這而一半的長度極端情況下都是null值，所以在序列化的時候可以把這部分數據排除出去，從而節省時間和空間：

     for (int i=0; i<size; i++) {
            s.writeObject(elementData[i]);
        }

註意ArrayList在序列化的時候用的size來遍歷原數組中的元素，而並不是elementData.length也就是數組的長度，而size的大小就是數組裏面非null元素的個數，所以這裏才采用了自定義序列化的方式。

到這裏細心的朋友可能有個疑問：HashMap中也就是采用的動態數組擴容為什麽它在序列化的時候用的是table.length而不是size呢，這其實很容易回答在HashMap中table.length必須是2的n次方，而且這個值會決定了好幾個參數的值，所以如果也把null值給去掉，那麽必須要重新的估算table.length的值，有可能造成所有數據的重新分布，所以最好的辦法就是保持原樣。

註意上面的null值，指的是table裏面Node元素是null，而並不是HashMap裏面的key等於null，而key是Node裏面的一個字段。

總結：

本文主要介紹了在HashMap和ArrayList中其核心的數據結構字段為什麽用transient修飾並分別介紹了其原因，所以使用序列化時，應該謹記effective java中的一句話：當一個對象的物理表示方法與它的邏輯數據內容有實質性差別時，使用默認序列化形式有N種缺陷，所以應該盡可能的根據實際情況重寫序列化方法。

理解Java集合框架裏面的的transient關鍵字（轉）