# HashMap source code analysis

## Structure diagram of HashMap

## Introduction to HashMap principle

Array: use a continuous storage unit to store data. For the search of the specified subscript, the time complexity is O(1); To search through a given value, you need to traverse the array and compare the given keywords and array elements one by one. The time complexity is O(n). Of course, for an ordered array, you can use binary search, interpolation search, Fibonacci search and other methods to improve the search complexity to O(logn); For the general insert and delete operation, it involves the movement of array elements, and its average complexity is also O(n)

Linear linked list: for operations such as adding and deleting linked lists (after finding the specified operation location), only the references between nodes need to be processed, and the time complexity is O(1), while the search operation needs to traverse the linked list for comparison one by one, and the complexity is O(n)

Binary tree: insert, search, delete and other operations on a relatively balanced ordered binary tree. The average complexity is O(logn).

Hash table: compared with the above data structures, the performance of adding, deleting, searching and other operations in the hash table is very high. Without considering the hash conflict, it can be completed only by one positioning, and the time complexity is O(1). Next, let's see how the hash table achieves the amazing constant order O(1). The hash table is composed of arrays and linked lists.

HashMap is realized by array + linked list + red black tree (the new red black tree in JDK1.8)

## Data structure of HashMap

### Linked list

Node is an internal class of HashMap, which implements map The entry interface is essentially a mapping (key value pair)

static class Node<K,V> implements Map.Entry<K,V> { final int hash;//The hash value is stored to locate the index position of the array final K key;//Store key value V value;//Store the value value corresponding to the key value Node<K,V> next;//Pointer to the next node Node(int hash, K key, V value, Node<K,V> next) { this.hash = hash; this.key = key; this.value = value; this.next = next; } public final K getKey() { return key; } public final V getValue() { return value; } public final String toString() { return key + "=" + value; } //The hash value is the bitwise XOR of the hash value of the hash value of the key public final int hashCode() { return Objects.hashCode(key) ^ Objects.hashCode(value); } public final V setValue(V newValue) { V oldValue = value; value = newValue; return oldValue; } public final boolean equals(Object o) { if (o == this)//If o is the current object return true; if (o instanceof Map.Entry) {//o is map The type of entry or its subclasses Map.Entry<?,?> e = (Map.Entry<?,?>)o; if (Objects.equals(key, e.getKey()) && Objects.equals(value, e.getValue()))//Judge whether key and value are completely equal return true; } return false; } }

### Red black tree

Here is only a part of the code for the red black tree. The red black tree has four more variables than the linked list: parent node, left node, right node and prev's previous peer node.

//Red black tree static final class TreeNode<k,v> extends LinkedHashMap.Entry<k,v> { TreeNode<k,v> parent; // Parent node TreeNode<k,v> left; //Left subtree TreeNode<k,v> right;//Right subtree TreeNode<k,v> prev; // Need to unlink next up deletion / / after deletion, you need to unlink the next step boolean red; //color property TreeNode(int hash, K key, V val, Node<k,v> next) { super(hash, key, val, next); } //Returns the root node of the current node final TreeNode<k,v> root() { for (TreeNode<k,v> r = this, p;;) { if ((p = r.parent) == null) return r; r = p; } } }

### Bit bucket

A very important field in the HashMap class is Node[] table, that is, hash bucket array. Obviously, it is an array of nodes

transient Node<k,v>[] table;//An array that stores (bit buckets)

### The underlying implementation of HashMap

First, there is an array in which each element is a linked list. When adding an element( key-value)First, when calculating the element key of hash Value to determine where to insert into the array, but there may be the same hash The element of the value has been placed in the same position of the array, and then it is added to the same array hash After the element of value, they are in the same position of the array, but form a linked list, so the array stores a linked list. When the length of the linked list is too long, the linked list will be converted into a red black tree, which greatly improves the efficiency of search.

## HashMap static utility

//Get the hash value of the key static final int hash(Object key) { int h; return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); } //If the class form of x is "class C implements comparable < C >", the class of x is returned; otherwise, null is returned static Class<?> comparableClassFor(Object x) { if (x instanceof Comparable) { // Determine whether the Comparable interface is implemented Class<?> c; Type[] ts, as; Type t; ParameterizedType p; if ((c = x.getClass()) == String.class) return c; // If it is a String type, directly return String class if ((ts = c.getGenericInterfaces()) != null) { // Determine whether there is a directly implemented interface for (int i = 0; i < ts.length; ++i) { // Traverse directly implemented interfaces if (((t = ts[i]) instanceof ParameterizedType) && // This interface implements generics ((p = (ParameterizedType)t).getRawType() == // Gets the type object of the interface without the parameter part Comparable.class) && // The type is Comparable (as = p.getActualTypeArguments()) != null && // Get generic parameter array as.length == 1 && as[0] == c) // There is only one generic parameter and the implementation type is the type itself return c; // Returns the type } } } return null; }

## Parameters of HashMap

// serial number private static final long serialVersionUID = 362498820763181265L; // The default initial capacity is 16 static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // Maximum capacity static final int MAXIMUM_CAPACITY = 1 << 30; // Default fill factor static final float DEFAULT_LOAD_FACTOR = 0.75f; // When the number of elements in the linked list exceeds 8 and the length of the Node[] table array does not exceed min_ TREEIFY_ When the value of capability is 64, the array capacity is expanded, otherwise the linked list structure is transformed into a red black tree structure for structural optimization static final int TREEIFY_THRESHOLD = 8; // When the number of nodes on the bucket is less than this value, the tree turns to the linked list static final int UNTREEIFY_THRESHOLD = 6; // The structure in the bucket is transformed into the minimum size of the table corresponding to the red black tree static final int MIN_TREEIFY_CAPACITY = 64; // An array of storage elements is always a power of 2 transient Node<k,v>[] table; // A set that holds concrete elements transient Set<map.entry<k,v>> entrySet; // size is the number of key value pairs that actually exist in the HashMap transient int size; // Counter for each expansion and change of map structure transient int modCount; // threshold is the maximum number of key value pairs that a HashMap can hold. Critical value when the actual size (capacity * filling factor) exceeds the critical value, the capacity will be expanded to double the original capacity int threshold; // Filling factor final float loadFactor;