备战秋招复习之HashMap

        之前大致阅读了jdk7和jdk8HashMap的源码，来记录一下自己的收获。起初学习基础的时候，以为会用就是会了，后来实习生面试的时候，被秒了，居然连个HashMap的内部类都不知道有哪些。现在秋招了，打算边复习边记录，这算是我第一次写博客吧。

     jdk7的时候具体实现就是数组+链表的方式。首先HashMap里面会有一个Entry<K,V>[] 的数组，默认大小为8，每次put的时候，HashMap都会重新计算一下key的hashcode，然后和数组length-1进行&运算，相当于mod，放到对应的table位置，如果table位置上Entry元素不是null，就会一直遍历这个Entry的next，如果不为null就继续下一个Entry的next，直至出现Entry的next为null，然后把Entry的next指向需要put的Entry。这里还需要说一下，如果某个Entry的key为null会直接存到tablep[0]的Entry链表上，如果已有为null的Entry，则用新value覆盖旧value。

     在hashmap里面会有个默认的负载因子 为0.75f，默认数量16，如果Hashmap里面的元素超过，数量*0.75，并且当前Entry数组位置的Entry不为null就会扩容，会将Entry<K,V>[]的length翻倍，

void addEntry(int hash, K key, V value, intbucketIndex) {
        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);
    }

        在hashmap里面修改容量初始大小和负载因子的方法是用一个重载的构造方法

 public HashMap(int initialCapacity, float loadFactor) {
        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;
        this.threshold = tableSizeFor(initialCapacity);
    }

jdk7中的hashmap大致实现思路就是这样，至于其他想了解的，可以自己看一下源码。

      接下来说一下jdk8中的hashmap的实现。

       jdk8中hashmap将Entry改成了Node，算是用于和treenode接轨。其他基本实现并没有多大的改变。如果put的时候没有发生第一次扩容，还是和jdk7没啥区别，依旧采用的是数组+链表。当冲突节点数>=8-1时，也就是数组已占用了7位置，就会将数组+链表的实现转换成红黑树

 if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);

在最后会进行一次判断是否达到阈值，看是否进行扩容

 if (++size > threshold)
            resize();

这里threshold计算是在resize（）里面的。

首先看这几个if判断

 if (oldCap > 0) {
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold
        }
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        else {               // zero initial threshold signifies using defaults
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }

最后一个else是第一次hashmap进行初始化的,

将阈值直接计算了出来 就是jdk7里面的 负载因子*默认大小。

第二次以后每次扩容将阈值 threshold 扩大两倍，之前的默认大小感觉就没啥用处了，就和阈值有关了。然后数组扩大，是按照以前的阈值大小，因为在上面的代码中else if 又将容量参数newCap设置为之前的阈值。然后下面的代码中新创建的数组大小就是newCap，所以数组的扩大，长度等于上一次的阈值，新的阈值变成了旧阈值的两倍。

if (newThr == 0) {
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
        threshold = newThr;
        @SuppressWarnings({"rawtypes","unchecked"})
            Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;

剩下红黑树的变化我就不一一细说了，不了解红黑树的同学，可以自己去百度一下。还是稍微提一下hashmap源码中的红黑树是按照key的hashcode进行排序的，从索引方法就能看出来

 final TreeNode<K,V> find(int h, Object k, Class<?> kc) {
            TreeNode<K,V> p = this;
            do {
                int ph, dir; K pk;
                TreeNode<K,V> pl = p.left, pr = p.right, q;
                if ((ph = p.hash) > h)
                    p = pl;
                else if (ph < h)
                    p = pr;
                else if ((pk = p.key) == k || (k != null && k.equals(pk)))
                    return p;
                else if (pl == null)
                    p = pr;
                else if (pr == null)
                    p = pl;
                else if ((kc != null ||
                          (kc = comparableClassFor(k)) != null) &&
                         (dir = compareComparables(kc, k, pk)) != 0)
                    p = (dir < 0) ? pl : pr;
                else if ((q = pr.find(h, k, kc)) != null)
                    return q;
                else
                    p = pl;
            } while (p != null);
            return null;
        }

左小右大.

第一次写博客真的感觉很累，写这点东西，就花了两个小时，就怕出什么错误，误导大家，有过有错误还希望大家能指出来。（转载请说明出处）。

                                                                                                                                                                                                              by    ~QB