Source code analysis of main methods of HashMap (JDK 1.8)

Posted by dkoolgeek on Mon, 20 Apr 2020 15:42:53 +0200

This article starts with the put, get and remove methods of HashMap, and analyzes the source flow
(specific algorithm of red black tree is not involved)
The structure of HashMap in jkd1.8 is in the form of array, linked list and red black tree
(when the red black tree is not transformed)

(when converted to mangrove)


1, About the static constants that HashMap needs to know

Default? Initial? Capacity array default initial capacity 16
Default load factor 0.75
Min? Tree? Capacity 64
The use of these static constants will be mentioned in the following method exploration

2, Method research


Arrays in HashMap are created when the put method is first called

Here is the whole process from entering put to creating array


After the key and value are passed in as parameters, the hash of the key is calculated, and then the putVal method is passed in

     * Implements Map.put and related methods.
     * @param hash hash for key
     * @param key the key
     * @param value the value to put
     * @param onlyIfAbsent if true, don't change existing value
     * @param evict if false, the table is in creation mode.
     * @return previous value, or null if none
    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = == null) {
               = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                    p = e;
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                return oldValue;
        if (++size > threshold)
        return null;
The whole process of putVal() is as follows
1. First, judge whether the table is null. If so, call resize()
     * Initializes or doubles table size.  If null, allocates in
     * accord with initial capacity target held in field threshold.
     * Otherwise, because we are using power-of-two expansion, the
     * elements from each bin must either stay at same index, or move
     * with a power of two offset in the new table.
     * @return the table
    final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;
        int newCap, newThr = 0;
        if (oldCap > 0) {
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        else {               // zero initial threshold signifies using defaults
            newCap = DEFAULT_INITIAL_CAPACITY;
        if (newThr == 0) {
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        threshold = newThr;
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;
        if (oldTab != null) {
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> e;
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;
                    if ( == null)
                        newTab[e.hash & (newCap - 1)] = e;
                    else if (e instanceof TreeNode)
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    else { // preserve order
                        Node<K,V> loHead = null, loTail = null;
                        Node<K,V> hiHead = null, hiTail = null;
                        Node<K,V> next;
                        do {
                            next =;
                            if ((e.hash & oldCap) == 0) {
                                if (loTail == null)
                                    loHead = e;
                           = e;
                                loTail = e;
                            else {
                                if (hiTail == null)
                                    hiHead = e;
                           = e;
                                hiTail = e;
                        } while ((e = next) != null);
                        if (loTail != null) {
                   = null;
                            newTab[j] = loHead;
                        if (hiTail != null) {
                   = null;
                            newTab[j + oldCap] = hiHead;
        return newTab;
After judging that the current table is null, initialize the load factor default load factor
Calculate the current array boundary default? Load? Factor * default? Initial? Capacity
(the first array boundary is 16 * 0.75 = 12, which will be doubled when the array exceeds the array boundary.
That is to say, when the element in the array reaches or is greater than 12, the array will be expanded for the first time, and the size will be 16 * 2 = 32)
Create and return a table object of the size default? Initial? Capacity.
(in general, resize is responsible for expanding the array capacity and initializing the array.)


The above is the creation process of the array in the HashMap object when the put method is called
2. If enter putVal(), judge that table is not null
Use hash value and (&) to calculate array subscript and judge whether it is empty
If so, create a node object and store it in an array
If not, start from the first place of the current subscript list and compare one by one
① If the hash and key values are the same, break exits the loop, and then value is replaced, and oldValue is returned
② If null is encountered during the process, a node object is created
Determine whether the red black tree conversion condition is met: if the current linked list length reaches 8, enter treeifyBin method
Judge the length of the table (if it is less than 64, call resize() to determine whether to increase the array
Instead, replace the current list with a red black tree

(the operation of traversing down the current subscript list of an array)

(replacement of value s with the same key)


3. Increase size (number of elements in the map) and modCount (number of operations on the map)



* Returns the value to which the specified key is mapped,
     * or {@code null} if this map contains no mapping for the key.
     * <p>More formally, if this map contains a mapping from a key
     * {@code k} to a value {@code v} such that {@code (key==null ? k==null :
     * key.equals(k))}, then this method returns {@code v}; otherwise
     * it returns {@code null}.  (There can be at most one such mapping.)
     * <p>A return value of {@code null} does not <i>necessarily</i>
     * indicate that the map contains no mapping for the key; it's also
     * possible that the map explicitly maps the key to {@code null}.
     * The {@link #containsKey containsKey} operation may be used to
     * distinguish these two cases.
     * @see #put(Object, Object)
    public V get(Object key) {
        Node<K,V> e;
        return (e = getNode(hash(key), key)) == null ? null : e.value;
Pass the hash of key and key into the getNode method, and get the value of the returned Node object
First, judge that the array is not null and the length is greater than 0
Use the hash value to find the first element of the column where the node may be (the currently passed in key may not exist)
Compare hash and key values by traversing the linked list vertically

(the first above is the first element of the list of possible node s)

If the first match is found, it will return directly

Otherwise, traverse down until the match or node is null



     * Implements Map.remove and related methods.
     * @param hash hash for key
     * @param key the key
     * @param value the value to match if matchValue, else ignored
     * @param matchValue if true only remove if value is equal
     * @param movable if false do not move other nodes while removing
     * @return the node, or null if none
    final Node<K,V> removeNode(int hash, Object key, Object value,
                               boolean matchValue, boolean movable) {
        Node<K,V>[] tab; Node<K,V> p; int n, index;
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (p = tab[index = (n - 1) & hash]) != null) {
            Node<K,V> node = null, e; K k; V v;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                node = p;
            else if ((e = != null) {
                if (p instanceof TreeNode)
                    node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
                else {
                    do {
                        if (e.hash == hash &&
                            ((k = e.key) == key ||
                             (key != null && key.equals(k)))) {
                            node = e;
                        p = e;
                    } while ((e = != null);
            if (node != null && (!matchValue || (v = node.value) == value ||
                                 (value != null && value.equals(v)))) {
                if (node instanceof TreeNode)
                    ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
                else if (node == p)
                    tab[index] =;
                return node;
        return null;

Similar to the logic of getNode, the hash value is used to find the possible location

If the first bit of the list matches:

Traversal of linked list:

Judge the type of node. If it is a linked list, use node.nest to replace the current location

The last operand + 1, size-1, returns the node object to be remove d

Topics: Java less