为什么“java.util.HashMap”中的成员字段“table”是瞬态的？

Question

I learnt, the transient keyword prevents the values of instance fields that are declared with transient keyword from being persisted when an object is serialized.

Below is the code from java.util.HashMap :

public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable {

             ....
             static class Node<K,V> implements Map.Entry<K,V> {...}
             transient Node<K,V>[] table;
}

Why values of instance field table are not part of serialization? Because values of table field is the actual content of class HashMap instance from implementation perspective.

Note: here is one exercise on using transient keyword.

Answer 1

How does one decide to not serialize a member by giving transient modifier?

1. When the field refers to a resource that doesn't make sense to be serialised. For example, a OutputStream or a Window handle.
2. When the field can be reconstructed from the other information that is serialised. This helps in reducing the amount of data that need to be written.

For example, why member field table is not part of serialization?

Because (2). Have a look at the readObject method in the HashMap class. The table field is reconstructed using the other information in the class.

Answer 2

An instance of HashMap has two parameters that affect its performance: initial capacity and load factor. The capacity is the number of buckets in the hash table, and the initial capacity is simply the capacity at the time the hash table is created.

Since the 'table', in the example you mentioned, gets constructed with other 2 params and used by this data structure for representation, one need not bother about its serialization.

Eg you could see it below :

   public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);

        // Find a power of 2 >= initialCapacity
        int capacity = 1;
        while (capacity < initialCapacity)
            capacity <<= 1;

        this.loadFactor = loadFactor;
        threshold = (int)(capacity * loadFactor);
        table = new Entry[capacity];
        init();
    }

Answer 3

Because Node<K, V>[] table is sparse, it is a waste of time to serialize all this array. Instead, we only need to serialize the non-empty elements in the array which is enough to reconstruct the table later.

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