#一、基本概念:html
惯例:我喜欢一开始把一篇文章涉及到的关键概念在文章开头就交代清楚,这样再小白的读者都能读懂文章。java
哈希表【散列表】:web
不是传统意义上的数组,能够理解为一开始固定容量固定位置的数组。ps:我的理解,表达可能不清楚,有可能让读者误解
,在哈希表中进行添加,删除,查找等操做,性能十分之高,不考虑哈希冲突的状况下,仅需一次定位便可完成,时间复杂度为O(1)。哈希函数【计算散列地址的方法】:咱们经过把当前元素的关键字经过某个函数映射到哈希表中的某个具体位置,经过哈希表数组下标一次定位就可完成操做;其中,这个映射函数f通常称为哈希函数。算法
存储位置 = f(关键字)
好比:当key1 不等于 key2时,可是f(key1) = f(key2),这种现象称之为哈希冲突。key1与key2也称之为这个散列函数的同义词。数组
负载因子【加载因子】: 负载因子= 实际填入表中的记录个数 / hash表的长度。
安全
容量:哈希表中能够装填的最大数量,也称hash表的长度。数据结构
##2.一、HashMap基本介绍:
并发
##2.二、Hash表内部讲解:
HashMap中的Hash表是Entry数组,Entry是HashMap的基本组成单元,每个Entry包含一个key-value键值对。ide
//HashMap的主干数组,能够看到就是一个Entry数组,初始值为空数组{},主干数组的长度必定是2的次幂。 transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE ; //实际存储的key-value键值对的个数 transient int size; //阈值,当table == {}时,该值为初始容量(初始容量默认为16);当table被填充了,也就是为table分配内存空间后,threshold通常为 capacity*loadFactory。 int threshold; //负载因子,表明了table的填充度有多少,默认是0.75 final float loadFactor; //用于快速失败,因为HashMap非线程安全,在对HashMap进行迭代时,若是期间其余线程的参与致使HashMap的结构发生变化了(好比put,remove等操做),须要抛出异常ConcurrentModificationException。 transient int modCount;
//每一个Hash表中的Entry数组: static class Entry<K,V> implements Map.Entry<K,V> { final K key; V value; Entry<K,V> next;//存储解决Hash冲突的单链表中的下一个Entry的引用变量 int hash;//key的hash值,对key的hashcode值进行hash()运算后获得的值,存储在Entry,避免重复计算 }
##2.三、构造函数:svg
HashMap(): //构建一个初始容量为 16,负载因子为 0.75 的 HashMap。 HashMap(int initialCapacity)://构建一个初始容量为 initialCapacity,负载因子为 0.75 的 HashMap。 HashMap(int initialCapacity, float loadFactor)://以指定初始容量、指定的负载因子建立一个 HashMap。
public HashMap(int initialCapacity, float loadFactor) { //此处对传入的初始容量进行校验,最大不能超过MAXIMUM_CAPACITY = 1<<30(230) if (initialCapacity < 0) throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity); if (initialCapacity > MAXIMUM_CAPACITY) initialCapacity = MAXIMUM_CAPACITY; if (loadFactor <= 0 || Float.isNaN(loadFactor)) throw new IllegalArgumentException("Illegal load factor: " + loadFactor); this.loadFactor = loadFactor; threshold = initialCapacity; init();//init方法在HashMap中没有实际实现,不过在其子类如 linkedHashMap中就会有对应实现 }
**注意:**在常规构造器中,没有为数组table分配内存空间(有一个入参为指定Map的构造器例外),而是在执行put操做的时候才真正构建table数组。
##2.四、源码解析:
###2.4.一、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; }
注意:
一、肯定key的hash表下标的步骤:
• 计算key的hashcode值。
• 经过哈希算法hash()来对key的hashcode值进行一系列的位运算【不少亦或^运算】获得key的hash值,以便散列均匀。
• 再经过indexFor()方法来对hash算法计算出来的值进行处理来最终肯定key在哈希表中的下标值。
//这是一个神奇的函数,用了不少的异或,移位等运算,对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); } static int indexFor(int h, int length) { return h & (length-1); }
//hash表的扩容操做: void addEntry(int hash, K key, V value, int bucketIndex) { //当size超过临界阈值threshold,而且即将发生哈希冲突时进行扩容 if ((size >= threshold) && (null != table[bucketIndex])) { resize(2 * table.length); hash = (null != key) ? hash(key) : 0; bucketIndex = indexFor(hash, table.length); } createEntry(hash, key, value, bucketIndex); }
当发生哈希冲突而且size大于阈值的时候,须要进行数组扩容,扩容时,须要新建一个长度为以前数组2倍的新的数组,而后将当前的Entry数组中的元素所有传输过去,扩容后的新数组长度为以前的2倍,因此扩容相对来讲是个耗资源的操做。
###2.4.二、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(); } 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; }
get方法的实现相对简单,key(hashcode)-->hash()计算hash值-->indexFor计算最终索引位置,找到对应位置table[i],再查看是否有链表,遍历链表。 遍历链表: • 先比较key的hash值是否一致 • 再比较key的内存地址是否一致。 key == k.key • 最后比较key的值是否一致。 key.equals(k)
###2.4.三、扩容原理:
//todo 有空来填坑
##2.五、注意点:
public class MyTest { private static class Person{ int idCard; String name; public Person(int idCard, String name) { this.idCard = idCard; this.name = name; } @Override public boolean equals(Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()){ return false; } Person person = (Person) o; //两个对象是否等值,经过idCard来肯定 return this.idCard == person.idCard; } } public static void main(String []args){ HashMap<Person,String> map = new HashMap<Person, String>(); Person person = new Person(1234,"乔峰"); //put到hashmap中去 map.put(person,"天龙八部"); //get取出,从逻辑上讲应该能输出“天龙八部” System.out.println("结果:"+map.get(new Person(1234,"萧峰"))); //实际返回null结果。 } }