STL-algorithm-2-CFANZ编程社区

HashMap源码分析
重要变量:

Node<K,V>[] table 存放单链表头结点的数组
size 存储结点数量
threshold 阈值,通过size和threshold比较来做扩容
loadFactor 加载因子

重要方法:

put(K key, V value) 添加结点
get(Object key) 查询结点

单链表Node结点中的一些变量:

hash hash值,每个添加的对象都有一个hash值,两个对象的hash值相同,添加时就会出现hash冲突/hash碰撞
key 元素的key值,用于查询元素时,hash值与key值进行比较,最终查询结果
value 元素的值
Node<K,V> next 下一个结点的指针

HashMap源码中put(K key, V value)方法剖析:

根据key获取到他的hash值,获取方式:(h = key.hashCode()) ^ (h >>> 16),
然后根据hash值与数组长度-1取余,得到元素存储在集合中的索引i,获取方式i = (n - 1) & hash,
如果获取到这个索引位置的单链表表头为空,直接将插入的数据构建出一个头结点;
如果获取到这个索引位置的单链表非空,则遍历该单链表,如果有相同的元素则返回,没有相同的元素则将这个插入的元素插入到链表尾部.

HashMap源码中get(Object key)方法剖析

根据参数key计算出hash值,然后通过hash值与table[]数组减1取模运算,得到这个元素存在于数组中的索引index,
根据index获取到这个table[]数组中的单链表,然后遍历单链表,通过hash值和key与单链表中的每一个结点进行比较,找到我们的那个结点Node,取出该Node的value值即可.

HashMap源码中resize()扩容方法剖析:

首先在第一次put添加数据时,调用resize()方法,此时数组table容量和阈值threshold默认值都为0,然后计算出新的数组容量大小和新的阈值大小,代码如下:

newCap = DEFAULT_INITIAL_CAPACITY;//1 << 4等于16
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);//0.75*16=12

在添加数据时,如果size大小大于threshold时,此时第二次调用resize()方法

首先将threshold扩展为原来的2倍,代码如下:
newThr = oldThr << 1; // double threshold
同时将table数组容量扩展为原来的2倍,代码如下:
newCap = oldCap << 1
最后遍历旧数组中存储的数据(数组中的每个元素Node都是单链表的表头),存储到新的数组中去(遍历单链表中的每个结点,将结点通过hash计算,存储到新的数组中去)

HashMap总结- Java8中有什么改进？

Hash冲突后不再是用链表来保存相同index的节点，相应的采用红黑树（高性能的平衡树）来保存冲突节点
节点查找优先级由 O（n）-> 提高到了O（logn）

什么是hash碰撞?如何解决hash碰撞问题?

hash碰撞就是添加数据时,不同的对象,计算出来的index索引值相同;解决办法就是将数组中每个元素采用单链表的形式进行存储,如果出现hash碰撞,就将这个对象存储到index位置单链表的尾部.

为什么需要加载因子?
加载因子loadFactor就是用来计算阈值threshold的,通过阈值判断,就可以在添加数据超过阈值threshold时,进行数组table的扩容resize操作.

面试题:`HashMap`常问的问题

“你用过HashMap吗?”“什么是HashMap?你为什么用到它?”
“你知道HashMap的工作原理吗?”
“你知道HashMap的get()方法的工作原理吗?”
“当两个对象的hashcode相同会发生什么?”
“如果两个键的hashcode相同，你如何获取值对象?”
“如果HashMap的大小超过了负载因子(load factor)定义的容量，怎么办?”“你了解重新调整HashMap大小存在什么问题吗?”
“为什么String, Interger这样的wrapper类适合作为键?”
“我们可以使用自定义的对象作为键吗?”

Android中的HashMap运用,Handler源码中相关联类ThreadLocal

`ThreadLocal<T>`源码分析

常用方法

set(T value)-> map.set(ThreadLocal<?> key, Object value)
map是当前线程对象t的一个变量,代码如下:

public T get() {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    return setInitialValue();
}

ThreadLocalMap getMap(Thread t) {
   return t.threadLocals;
}

public void set(T value) {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
}

static class ThreadLocalMap {
	//Entry数组,根据ThreadLocal作为key得到hash值与数组长度取模,计算出存入数组的索引
	private Entry[] table;

	//根据传入ThreadLocal作为key,然后通过key的hash值计算得出,存入的元素的索引,
	//根据索引从Entry[]数组中取出这个Entry对象
	private Entry getEntry(ThreadLocal<?> key) {
        int i = key.threadLocalHashCode & (table.length - 1);
        Entry e = table[i];
        if (e != null && e.get() == key)
            return e;
        else
            return getEntryAfterMiss(key, i, e);
    }
	
	//这个方法会从ThreadLocalMap中的Entry[]数组中,
	//遍历是否有我们存入的以ThreadLocal作为key的Entry对象;
	//有则直接更改该Entry中的value值;
	//无则将传入的value构建出一个Entry对象,赋值给Entry[]数组中遍历到的第一个空的Entry
	private void set(ThreadLocal<?> key, Object value) {

       // We don't use a fast path as with get() because it is at
       // least as common to use set() to create new entries as
       // it is to replace existing ones, in which case, a fast
       // path would fail more often than not.

       Entry[] tab = table;
       int len = tab.length;
       int i = key.threadLocalHashCode & (len-1);

		//这个循环会不停的遍历数组中从索引为i开始,i++,取出的Entry对象为null的对象为止
       for (Entry e = tab[i];
            e != null;
            e = tab[i = nextIndex(i, len)]) {
           ThreadLocal<?> k = e.get();

           if (k == key) {
               e.value = value;
               return;
           }

           if (k == null) {
               replaceStaleEntry(key, value, i);
               return;
           }
       }
	   //这里的i可能我们取模计算得到的i不相等,因为要从数组中i开始往后遍历,
	   //取出第一个Entry为null的对象,然后将传入的value构建的Entry对象赋值给这个Entry为null的对象
       tab[i] = new Entry(key, value);
       int sz = ++size;
       if (!cleanSomeSlots(i, sz) && sz >= threshold)
           rehash();
   }
}

ThreadLocalMap是一个类似HashMap的集合,他里面的数据结构是数组Entry[],数组中的每一个元素是一个对象Entry,这个对象里面只有一个value变量,所以数组中每个元素的数据结构不是HashMap那样的单链表.

这里通过ThreadLocal作为key获取到经过hash运算(CAS机制)得到唯一的hash值,取模得到索引i,然后根据当前索引i开始自增(i = nextIndex(i, len))遍历数组中元素Entry为null的值,通过set(value)方法传入的value构建出Entry对象,存储在这个Entry为null的索引位置.