准备☞ HashMap 的数据结构及存储原理

HashMap的数据结构

• 在JDK 8 之前 HashMap 的数据结构组成：数组 + 链表 两种数据结构。

数组
优点：存储区间连续，寻址容易 ，按下标随机访问效率高O(1)
缺点：占用内存严重，插入删除困难
链表
优点：存储地址不连续，可宽展空间，插入，删除效率高
缺点：访问效率低 O(n)
哈希表
综合了数组和链表的特性，既寻址容易，插入删除效率又高

• 在 JDK 8 中，由三种数据结构组成： 数组 + （链表 或者 红黑树）。结构如下图

问题：什么是HashMap？为什么要用到HashMap?

1 .HashMap是基于哈希表的Map接口的非同步实现。HashMap 不保证映射的顺序，特别是不能保证顺序一致不变。
2 .HashMap 存储的是键值对，可以支持任何类型的作为Key 或者 value，并且可以存储null键和 null 值,HashMap数据存储很快，插入删除效率高。

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

HashMap的工作原理

HashMap 是哈希法(hashing）或者 散列法的原理，通过put(key, value) 存储键值对对象到 HashMap中， 通过 get(key) 从 HashMap 中获取对象。当通过 put(key , value) 方法传递 key 和 value 时，首先 调用 key.hashCode() , 通过返回的 hashCode 来找到 bucket 位置来存储 Entry（键值对）对象。需要说明一点，HashMap 是在bucket 中存储 键值对 对象，即 Map.Entry.

HashMap 可以看成一个大的数组，然后每个数组元素的类型是Node 类型，Node类型有两个子类，TreeNode 和 Entry ,如果是链表即使 Node类，红黑树 是 TreeNode 类

   public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }

    static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

    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 = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

我们看到在 put(key, value) 方法里调用了 hash(key) 方法，来得到该 key 的 hashCode. hash(key)方法主要目的是使得高低bit 位参与到Hash 计算中，从而减少 hash 冲突。

在 putValue() 函数插入数据方法时，会判断节点是链表还是红黑树，分别对不同的赋值方法，如果单个bucket 的节点数量大于 8 个，会把链表转化成红黑树。

public V get(Object key) {
        Node<K,V> e;
        return (e = getNode(hash(key), key)) == null ? null : e.value;
    }

final Node<K,V> getNode(int hash, Object key) {
        Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (first = tab[(n - 1) & hash]) != null) {
            if (first.hash == hash && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k))))
                return first;
            if ((e = first.next) != null) {
                if (first instanceof TreeNode)
                    return ((TreeNode<K,V>)first).getTreeNode(hash, key);
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        return e;
                } while ((e = e.next) != null);
            }
        }
        return null;
    }

get方法 也调用了 hash(key) 方法来获取 hashCode。
接着调用 getNode(hash, key) 查找符合条件的结点

问题：HashMap 的工作原理你了解么？

答：HashMap 是哈希法(hashing 或者 散列法)的原理，通过put(key, value) 存储对象到 HashMap中， 通过 get(key) 从 HashMap 中获取对象。当通过 put(key , value) 方法传递 key 和 value 时，首先 调用 key.hashCode() , 通过返回的 hashCode 来找到 bucket 位置 来存储 Entry （键值对）对象。需要说明一点，HashMap 是在bucket 中存储 键值对 对象，即 Map.Entry.

问题：HashMap 的put() ,get() 方法工作原理？
或者 HashMap 的存取过程是什么？

答:
put 方法的过程：
put(key, value) 是把键值对 对象存储到 HashMap 中。
首先获取到 key后，通过Hash函数 (hash(key)),获取到 key 的 hashCode (int hash = key.hashCode()),这个值是一个固定的int 类型的值。
其次 通过hashCode 获取到 bucket 位置（数组下标 index = hash % Entry[].length ，hashCode值对bucket数求模）来存储 Entry 对象。

get方法过程：

首先获取key 后，通过Hash函数 (hash(key)),获取到 key 的 hashCode (int hash = key.hashCode()),这个值是一个固定的int 类型的值。
其次 通过hashCode 获取到 bucket 位置（数组下标 index = hash % Entry[].length ，hashCode值对bucket数求模）
最后 遍历LinkedList ，调用keys.equals()方法 在LinkedList找到正确的节点，进而找到正确的值对象。

问题：
1 如果两个 key 的 hashCode 相同会发生什么？
2 如何获取 value 对象 ？

答：
1 如果两个 key对象 的 hashCode 相同时，它们的 bucket 也相同，会发上碰撞问题，使用LinkedList 解决碰撞问题，将键值对 对象存储在 LinkedList 的下一个结点中。
2 获取 value 对象的时候，会调用get() 方法，接着会调用Hash函数 获取键对象的 hashCode，找到bucke位置，接着遍历 LinkedList ，通过keys. equals() 方法，找到 LinkedList 中的正确结点。最终找到 value 对象。

存储方式问题：
在HashMap 中存放一系列键值对，其中 key 为某个自定义的类型，放入HashMap 后，在外部把一个 key 属性进行修改， 然后在用这个 key 从 HashMap 里取出元素， 这个时候 HashMap 会返回什么？

答：返回 Null
第一次存储的时候，首先获取到 key后，通过Hash函数 (hash(key)),获取到 key 的 hashCode (int hash = key.hashCode()),这个值是一个固定的int 类型的值。
其次 通过hashCode 获取到 bucket 位置（数组下标 index = hash % Entry[].length ，hashCode值对bucket数求模）来存储 Entry 对象。
当我们去获取元素的时候，key.hashCode 已经发生变化，所以这里hash函数结果也发生了变化，所以当用这个key 获得hashCode去需要 bucket 的存储位置是一个错误的位置，无法找到目标元素。

结论：当我们把键值对 对象存储到hashMap中后，不要去修改 key 的属性

负载因子

问题：如果HashMap的大小超过了负载因子(load factor)定义的容量，怎么办？
答：哈希表的默认负载因子是0.75，如果map填满75%的bucket时，必须调整backet的大小,创建原来HashMap大小的两倍的bucket数组，并将原来的对象放入新的bucket数组中。这个过程叫作rehashing.当容量已经达到最大可能值时，那么该方法就将容量调整到Integer.MAX_VALUE返回，这时，需要创建一张新表，将原表的映射到新表中。