Java HashMap implementation principle

Concept

1. hash

The translation is a hash, and there is also a way to name hash. We should know what we have learned about the data structure. Hash is to use the hash algorithm to obtain a fixed-length output value of any length input value. The hash algorithm is not introduced here.

Java hashmap Implementation 1. Storage Structure

First, we know that the element stored in map is Entry. .

The hashmap class uses an Entry array for storage. Each element in the array may correspond to a linked list.

/**     * The table, resized as necessary. Length MUST Always be a power of two.     */    transient Entry[] table;

The constructor, which we generally call:

/**     * Constructs an empty HashMap with the default initial capacity     * (16) and the default load factor (0.75).     */    public HashMap() {        this.loadFactor = DEFAULT_LOAD_FACTOR;        threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);        table = new Entry[DEFAULT_INITIAL_CAPACITY];        init();    }

2. put Method: add data to hashmap

/**     * Associates the specified value with the specified key in this map.     * If the map previously contained a mapping for the key, the old     * value is replaced.     *     * @param key key with which the specified value is to be associated     * @param value value to be associated with the specified key     * @return the previous value associated with key, or     *         null if there was no mapping for key.     *         (A null return can also indicate that the map     *         previously associated null with key.)     */    public V put(K key, V value) {        if (key == null)            return putForNullKey(value);        int hash = hash(key.hashCode());        int i = indexFor(hash, table.length);        for (Entry
 
   e = table[i]; e != null; e = e.next) {            Object k;            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {                V oldValue = e.value;                e.value = value;                e.recordAccess(this);                return oldValue;            }        }        modCount++;        addEntry(hash, key, value, i);        return null;    }
 

We can see that the hash value is re-calculated for the key first, and then the small icon of the array is found based on the value. If the position of the array has a value, it is stored as a linked list, place the new value in the linked list header.

/**     * Applies a supplemental hash function to a given hashCode, which     * defends against poor quality hash functions.  This is critical     * because HashMap uses power-of-two length hash tables, that     * otherwise encounter collisions for hashCodes that do not differ     * in lower bits. Note: Null keys always map to hash 0, thus index 0.     */    static int hash(int h) {        // This function ensures that hashCodes that differ only by        // constant multiples at each bit position have a bounded        // number of collisions (approximately 8 at default load factor).        h ^= (h >>> 20) ^ (h >>> 12);        return h ^ (h >>> 7) ^ (h >>> 4);    }

3. get Method

 public V get(Object key) {        if (key == null)            return getForNullKey();        int hash = hash(key.hashCode());        for (Entry
 
   e = table[indexFor(hash, table.length)];             e != null;             e = e.next) {            Object k;            if (e.hash == hash && ((k = e.key) == key || key.equals(k)))                return e.value;        }        return null;    }
 

Calculate the hash value of the key, find the corresponding position in the array, and then traverse the linked list at the position through the for loop, and compare the search with equals.