面试宝典:数据结构-HashMap

常用数据结构在新增、查找等基础操作上的性能

1、数组

• 采用一段连续的存储单元来存储数据
  
• 对于指定下标的查找，时间复杂度为O(1)
  
• 通过给定值进行查找，需要遍历数组，逐一比对给定关键字和数组元素，时间复杂度为O(n)
  
• 对于有序数组，则可采用二分查找，插值查找，斐波那契查找等方式，可将查找复杂度提高为O(logn)
  
• 对于一般的插入删除操作，涉及到数组元素的移动，其平均复杂度也为O(n)
  

2、线性链表

• 对于链表的新增，删除等操作（在找到指定操作位置后），仅需处理结点间的引用即可，时间复杂度为O(1)
  
• 查找操作需要遍历链表逐一进行比对，复杂度为O(n)
  

3、二叉树

对一棵相对平衡的有序二叉树，对其进行插入，查找，删除等操作，平均复杂度均为O(logn)

4、哈希表

• 在哈希表中进行添加，删除，查找等操作，性能十分之高 不考虑哈希冲突的情况下 仅需一次定位即可完成，时间复杂度为O(1)

数据结构的物理存储结构

1、顺序存储结构

2、链式存储结构

顺序存储结构和链式存储结构

JDK 1.8 hashmap put逻辑图

注意：JDK8之后

• 如果哈希表单向链表中元素超过8个，那么单向链表这种数据结构会变成红黑树数据结构当
  
• 红黑树上的节点数量小于6个，会重新把红黑树变成单向链表数据结构
  

hash冲突

概念

对某个元素进行哈希运算，得到一个存储地址，然后要进行插入的时候，发现已经被其他元素占用了，其实这就是所谓的哈希冲突，也叫哈希碰撞

冲突必然性

数组是一块连续的固定长度的内存空间，再好的哈希函数也不能保证得到的存储地址绝对不发生冲突

解决冲突方式

哈希冲突的解决方案有多种:

1、开放定址法（发生冲突，继续寻找下一块未被占用的存储地址）

2、再散列函数法

3、链地址法 （HashMap即是采用了链地址法，也就是数组+链表的方式）

深入源码分析实现原理

Entry是HashMap中的一个静态内部类

static class Entry<K,V> implements Map.Entry<K,V> {
        final K key;
        V value;
        Entry<K,V> next;//存储指向下一个Entry的引用，单链表结构
        int hash;//对key的hashcode值进行hash运算后得到的值，存储在Entry，避免重复计算

        /**
         * Creates new entry.
         */
        Entry(int h, K k, V v, Entry<K,V> n) {
            value = v;
            next = n;
            key = k;
            hash = h;
        } 

hashmap总体结构

HashMap中的链表出现越少，性能才会越好

重要字段

/**实际存储的key-value键值对的个数*/
transient int size;

/**阈值，当table == {}时，该值为初始容量（初始容量默认为16）；当table被填充了，也就是为table分配内存空间后，
threshold一般为 capacity*loadFactory。HashMap在进行扩容时需要参考threshold，后面会详细谈到*/
int threshold;

/**负载因子，代表了table的填充度有多少，默认是0.75
加载因子存在的原因，还是因为减缓哈希冲突，如果初始桶为16，等到满16个元素才扩容，某些桶里可能就有不止一个元素了。
所以加载因子默认为0.75，也就是说大小为16的HashMap，到了第13个元素，就会扩容成32。
*/
final float loadFactor;

/**HashMap被改变的次数，由于HashMap非线程安全，在对HashMap进行迭代时，
如果期间其他线程的参与导致HashMap的结构发生变化了（比如put，remove等操作），
需要抛出异常ConcurrentModificationException*/
transient int modCount;

initialCapacity默认为16，loadFactory默认为0.75

构造器

没有为数组table分配内存空间（有一个入参为指定Map的构造器例外）

而是在执行put操作的时候才真正构建table数组

put函数

public V put(K key, V value) {
        //如果table数组为空数组{}，进行数组填充（为table分配实际内存空间），入参为threshold，
        //此时threshold为initialCapacity 默认是1<<4(24=16)
        if (table == EMPTY_TABLE) {
            inflateTable(threshold);
        }
       //如果key为null，存储位置为table[0]或table[0]的冲突链上
        if (key == null)
            return putForNullKey(value);
        int hash = hash(key);//对key的hashcode进一步计算，确保散列均匀
        int i = indexFor(hash, table.length);//获取在table中的实际位置
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
        //如果该对应数据已存在，执行覆盖操作。用新value替换旧value，并返回旧value
            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++;//保证并发访问时，若HashMap内部结构发生变化，快速响应失败
        addEntry(hash, key, value, i);//新增一个entry
        return null;
    }

inflateTable函数

• 用于为主干数组table在内存中分配存储空间
  
• 通过roundUpToPowerOf2(toSize)可以确保capacity为大于或等于toSize的最接近toSize的二次幂，比如toSize=13,则capacity=16;to_size=16,capacity=16;to_size=17,capacity=32.
  

private void inflateTable(int toSize) {
        int capacity = roundUpToPowerOf2(toSize);//capacity一定是2的次幂
        /**此处为threshold赋值，取capacity*loadFactor和MAXIMUM_CAPACITY+1的最小值，
        capaticy一定不会超过MAXIMUM_CAPACITY，除非loadFactor大于1 */
        threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
        table = new Entry[capacity];
        initHashSeedAsNeeded(capacity);
    }

roundUpToPowerOf2函数

使得数组长度一定为2的次幂，Integer.highestOneBit是用来获取最左边的bit（其他bit位为0）所代表的数值.

private static int roundUpToPowerOf2(int number) {
        // assert number >= 0 : "number must be non-negative";
        return number >= MAXIMUM_CAPACITY
                ? MAXIMUM_CAPACITY
                : (number > 1) ? Integer.highestOneBit((number - 1) << 1) : 1;
    }

hash函数

• 用了很多的异或，移位等运算
  
• 对key的hashcode进一步进行计算以及二进制位的调整等来保证最终获取的存储位置尽量分布均匀
  

final int hash(Object k) {
        int h = hashSeed;
        if (0 != h && k instanceof String) {
            return sun.misc.Hashing.stringHash32((String) k);
        }

        h ^= k.hashCode();

        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }

indexFor

以上hash函数计算出的值，通过indexFor进一步处理来获取实际的存储位置

/**
* 返回数组下标
*/
static int indexFor(int h, int length) {
    return h & (length-1);
}  

1、h&（length-1）保证获取的index一定在数组范围内

举个例子，默认容量16，length-1=15，h=18,转换成二进制计算为index=2

2、位运算对计算机来说，性能更高一些（HashMap中有大量位运算）

终存储位置的确定流程

addEntry函数

void addEntry(int hash, K key, V value, int bucketIndex) {
        if ((size >= threshold) && (null != table[bucketIndex])) {
            resize(2 * table.length);//当size超过临界阈值threshold，并且即将发生哈希冲突时进行扩容
            hash = (null != key) ? hash(key) : 0;
            bucketIndex = indexFor(hash, table.length);
        }

        createEntry(hash, key, value, bucketIndex);
    }

• 当发生哈希冲突并且size大于阈值的时候，需要进行数组扩容
  
• 扩容时，需要新建一个长度为之前数组2倍的新的数组
  
• 然后将当前的Entry数组中的元素全部传输过去，扩容后的新数组长度为之前的2倍
  
• 扩容相对来说是个耗资源的操作
  

为何HashMap的数组长度一定是2的次幂

resize扩容函数

void resize(int newCapacity) {
        Entry[] oldTable = table;
        int oldCapacity = oldTable.length;
        if (oldCapacity == MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return;
        }

        Entry[] newTable = new Entry[newCapacity];
        transfer(newTable, initHashSeedAsNeeded(newCapacity));
        table = newTable;
        threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
    }

如果数组进行扩容，数组长度发生变化，而存储位置 index = h&(length-1),index也可能会发生变化，需要重新计算index

transfer函数

void transfer(Entry[] newTable, boolean rehash) {
        int newCapacity = newTable.length;
     //for循环中的代码，逐个遍历链表，重新计算索引位置，将老数组数据复制到新数组中去（数组不存储实际数据，所以仅仅是拷贝引用而已）
        for (Entry<K,V> e : table) {
            while(null != e) {
                Entry<K,V> next = e.next;
                if (rehash) {
                    e.hash = null == e.key ? 0 : hash(e.key);
                }
                int i = indexFor(e.hash, newCapacity);
                //将当前entry的next链指向新的索引位置,newTable[i]有可能为空，有可能也是个entry链，如果是entry链，直接在链表头部插入。
                e.next = newTable[i];
                newTable[i] = e;
                e = next;
            }
        }
    }

• 将老数组中的数据逐个链表地遍历 扔到新的扩容后的数组中
  
• 数组索引位置的计算是通过 对key值的hashcode进行hash扰乱运算后
  
• 通过和 length-1进行位运算得到最终数组索引位置
  

1、

HashMap的数组长度一定保持2的次幂

比如16的二进制表示为 10000，那么length-1就是15，二进制为01111

同理扩容后的数组长度为32，二进制表示为100000，length-1为31，二进制表示为011111

• 会保证低位全为1，而扩容后只有一位差异，也就是多出了最右位的1
  
• 在通过 h&(length-1)的时候，只要h对应的最左边的那一个差异位为0，就能保证得到的新的数组索引和老数组索引一致(大大减少了之前已经散列良好的老数组的数据位置重新调换)
  

2、

数组长度保持2的次幂，length-1的低位都为1，会使得获得的数组索引index更加均匀

3、

• &运算，高位是不会对结果产生影响的（hash函数采用各种位运算可能也是为了使得低位更加散列）
  
• 只关注低位bit，如果低位全部为1，那么对于h低位部分来说，任何一位的变化都会对结果产生影响，也就是说，要得到index=21这个存储位置，h的低位只有这一种组合
  

4、

• 如果不是2的次幂，也就是低位不是全为1此时，要使得index=21，h的低位部分不再具有唯一性了，哈希冲突的几率会变的更大
  
• index对应的这个bit位无论如何不会等于1了，而对应的那些数组位置也就被白白浪费了
  

get函数

public V get(Object key) {
     //如果key为null,则直接去table[0]处去检索即可。
        if (key == null)
            return getForNullKey();
        Entry<K,V> entry = getEntry(key);
        return null == entry ? null : entry.getValue();
 }

get方法通过key值返回对应value，如果key为null，直接去table[0]处检索

getEntry函数

final Entry<K,V> getEntry(Object key) {
            
        if (size == 0) {
            return null;
        }
        //通过key的hashcode值计算hash值
        int hash = (key == null) ? 0 : hash(key);
        //indexFor (hash&length-1) 获取最终数组索引，然后遍历链表，通过equals方法比对找出对应记录
        for (Entry<K,V> e = table[indexFor(hash, table.length)];
             e != null;
             e = e.next) {
            Object k;
            if (e.hash == hash && 
                ((k = e.key) == key || (key != null && key.equals(k))))
                return e;
        }
        return null;
    }    

key(hashcode)–>hash–>indexFor–>最终索引位置，找到对应位置table[i]，再查看是否有链表，遍历链表，通过key的equals方法比对查找对应的记录

e.hash == hash 这里是否有必要判断？从而引出下个话题

重写equals方法需同时重写hashCode方法

如果没有重写hashCode方法

put:key(hashcode1)–>hash–>indexFor–>最终索引位置

get:通过key取出value的时候 key(hashcode1)–>hash–>indexFor–>最终索引位置

由于hashcode1不等于hashcode2，导致没有定位到一个数组位置而返回逻辑上错误的值null

小结：

在重写equals的方法的时候，必须注意重写hashCode方法

同时还要保证通过equals判断相等的两个对象，调用hashCode方法要返回同样的整数值

而如果equals判断不相等的两个对象，其hashCode可以相同（只不过会发生哈希冲突，应尽量避免）

HashMap的数据结构

特点简介

• 无序

因为不一定挂到哪一个单向链表上的，因此加入顺序和取出也不一样

• 不可重复

1、使用equals方法来保证HashMap集合key不可重复，如key重复来，value就会覆盖

2、存放在HashMap集合key部分的元素，其实就是存放在HashSet集合中，则HashSet集合也需要重写equals和hashCode方法