HashMap的源码学习

1、HashMap理论上就是一个存储数据的集合脱离不了CRUD

HashMap1.7 与HashMap1.8的比较

HashMap1.8比1.7多了红黑树，作用就是优化查询，具体实现需后续了解

扩容出也做出了一些优化，jdk7并发可能会出现链表环（就是死循环），而jdk8优化了，使用了高低位，请看扩容的方法

（但是我觉得如果转为了红黑树，插入就会比之前慢，理论上转红黑树的情况不多，个人理解，因为每次插入都会重新打破红黑树的结构，但是查询效率变成了O(logN)，链表的查询小于为O(N)）

问题：1.为什么hashMap可以让我们自定义数组容量，但是put的时候又自己设置成2的次幂，接近且大于我们的容量？

答：设置成2的次幂是在put的时候，1.可以直接用hash&（m-1）计算取余，取代之前的n%m取余,提高运算效率。2.保证索引值在在桶内，不会数组越界 在算索引的位置的时候，不会数组越界

newTab[e.hash & (newCap - 1)] = e;这段代码就是说明

2.为什么加载因子默认设置成0.75

答：只能说在时间和内存上取了一个相对的值，假如我们使用0.5就扩容，这样就会浪费内存，而使用1扩容，相对来说，效率就会慢一些

3.为什么链表转红黑树的阈值设置成8

答：红黑树是一个类似于平衡二叉树的东西，运算效率为O(logN) 而链表的效率为O(N) 但是链表的数目相对来说比较上的时候，效率基本可以说忽略不计，而设置成8，应该是研究员经过计算，（在一个就算链表长度大于阈值了，转了红黑树，相对查询效率快很多，但是put一个元素可能就会打破红黑树 ，这个是个人理解）

4.二进制运算（基础）

学习学习二进制运算

5.hash算法计算规则

请找第8个节点

6.tableSizeFor()是否为一个bug？？

如果刚开始看源码，肯定觉得这会是一个bug，理由是吧阈值设置成了2的次幂，理论上应该设置成2的次幂乘以加载因子，但是当看到put()方法的时候，里面的扩容才会去算阈值

2、HashMap的数据结构

数组+链表+红黑树

通过源码我们知道，链表到达一定值得时候会转化成红黑树

public class HashMap<K,V> extends AbstractMap<K,V>
    //实现Cloneable 目的就是可以使用Object的克隆方法
    //实现Serializable目的就是序列化
    implements Map<K,V>, Cloneable, Serializable{
     private static final long serialVersionUID = 362498820763181265L;
    //默认的初始化容量
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
    //最大容量（不允许大于此容量）
    static final int MAXIMUM_CAPACITY = 1 << 30;
    //加载因子（扩容需要的）
    static final float DEFAULT_LOAD_FACTOR = 0.75f;
    //阈值（链表转红黑树的阈值）
    static final int TREEIFY_THRESHOLD = 8;
    //阈值（红黑树转链表的阈值）
    static final int UNTREEIFY_THRESHOLD = 6;
    //理解为（动态数组大于这个值时hash表上的链表才会转化为红黑树）
    static final int MIN_TREEIFY_CAPACITY = 64;
    //transient关键字  是table不参数序列化（为啥？）
    //重写了Serializable的writeObject和readObject方法使用这个在序列化存储元素 table就是表示我们知道数组的数据结构了
    transient Node<K,V>[] table;
    //暂时没理解这个的东西
    transient Set<Map.Entry<K,V>> entrySet;
    //Map的键值对个数
    transient int size;
    //之前了解过，每次新增修改删除都会+1，具体作用在做了解
    transient int modCount;
    //阈值数组扩容的条件
    int threshold;
    //加载因子
    final float loadFactor;

3、HashMap的构造方法

public HashMap() {
		//无参构造方法，默认加载因子为0.75
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }
public HashMap(int initialCapacity) {
    	//参数为需要初始化容量为给定值的构造方法，加载因子为默认
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }
//参数为需要初始化容量的给定值，和加载因子给定值的构造方法
public HashMap(int initialCapacity, float loadFactor) {
    	//不能初始化容量为负数，会报错
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
    	//给定值大于最大值 那容量就是最大值2的30次方
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
    	//判断加载因子是否正常 
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
        this.loadFactor = loadFactor;
    	//这里的阈值成了2的指数次幂？？？是一个bug？？看到后面才知道在扩容的时候完成阈值的计算，这里顶多算帮组记录数组容量的一个变量。。。但是暂时还没有明白为啥要这么做
        this.threshold = tableSizeFor(initialCapacity);
    }
//这一段就是赋值 数组阈值 假如我们填写的容量为 12
//12 0000 1110 >>> 1 =0000 0111
//n = 12 | 7 -->0000 1110 | 0000 0111-->0000 1111
//              0000 1111 | 0000 0011-->0000 1111
//最终得出的值肯定是2的指数次幂
static final int tableSizeFor(int cap) {
        int n = cap - 1;
        n |= n >>> 1;
        n |= n >>> 2;
        n |= n >>> 4;
        n |= n >>> 8;
        n |= n >>> 16;
        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
    }

4、HashMap的put（新增修改）

public V put(K key, V value) {
	//hash(key) 就是key的hash值 onlyIfAbsent:false evict:ture
    return putVal(hash(key), key, value, false, true);
    }

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
    	//定义1个node数组，1一个node
        Node<K,V>[] tab; Node<K,V> p; int n, i;
    	//table指我们的键值对，如果第一次肯定是为null tab.length第一次肯定也是0
        if ((tab = table) == null || (n = tab.length) == 0)
            //第一次创建，reize()扩容也就说创建一个默认的容量 16
            n = (tab = resize()).length;
    	//此处可以看到为什么数组值要设置成2的次幂 (n - 1) & hash] 就是等于jdk7取余操作 此操作有人测试提速10%左右.....点赞
    	//这里就是判断取余后节点是不是空的，如果是空的直接就放在这里，next就是null
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            //如果不是空 是不是应该就去读链表
            Node<K,V> e; K k;
            //p就是数组上的那个值，如果hash值相等直接...条件--》给新的node赋值
            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);
            //如果与数据上的index的值不相等，就要去读链表上的数据，一个一个比较，如果都不相等，就放到量表的尾部，如果有相等的就直接赋值
            else {
                for (int binCount = 0; ; ++binCount) {
                    //判断p的next没有值，直接给p的next赋值
                    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;
                //此方法说是给LinkedHashMap有关，暂时放后理解
                afterNodeAccess(e);
                return oldValue;
            }
        }
    	//modCount记录Hashmap的修改删除的次数 （个人理解，当我们遍历的时候，去修改一个值，如果允许，则遍历并不是我们想要的值，所以这里判断修改的次数expectedModCount是否和modCount相等）
        ++modCount;
    	//判断数组是否达到数组扩容的阈值，达到就扩容
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }
	//扩容的操作 
 final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;
        int newCap, newThr = 0;
     	//旧数组容量>0
        if (oldCap > 0) {
            //如果操作最大容量，就不扩容了
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            //如果乘以2小于int的最大值，且大于默认值，newThr = 老数组容量乘以2
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold
        }
     	//阈值大于0，新的容量=老的阈值
        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);
        }
     	//新的阈值=0  也是算阈值的
        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;
     	//判断老的数组是不是空的，如果不是空的，应该要把数据转移过来
     	//说是扩容其实就是把新建一个容量是之前2倍的数组，然后在那之前的数组的位置拿过来
        if (oldTab != null) {
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> e;
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;//这个编写方式值得我们学习，当我们在编程中遇到不需要的的对象或者变量的时候，应该置为null，因为这有利于GC的回收
                    //判断链表有没有值，如果没有值，直接根据取余计算得到table新的index
                    if (e.next == null)
                        newTab[e.hash & (newCap - 1)] = e;
                    //此处为红黑树的逻辑，暂不学习
                    else if (e instanceof TreeNode)
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    //这个地方就是有链表的处理逻辑
                    else { // preserve order
                        Node<K,V> loHead = null, loTail = null;
                        Node<K,V> hiHead = null, hiTail = null;
                        Node<K,V> next;
                        //处理链表
                        do {
                            next = e.next;
                           	//这里的逻辑非常高明 高位和地位分开处理，与JDK7有差异
                            //oldCap 老的数组容量为16 那0001 0000
                            //e.hash 只要是小于16，结果肯定都是 0
                            //假如e.hash是17 二进制就是 0001 0001 &运算之后就是0001 0000 结果16
                            //e.hash 是15 二进制位 0000 1111 &运算之后结果就0000 0000结果为0
                            
                            if ((e.hash & oldCap) == 0) {
                                if (loTail == null)
                                    loHead = e;
                                else
                                    loTail.next = e;
                                loTail = e;
                            }
                            else {
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);
                        //这里就是放在对应的index为，如果高位则index+老数组的容量，如果是低位，直接放在index的位置上
                        if (loTail != null) {
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }
//以上为HashMap的put方法基于JDK8

5、HashMap的remove（删除）

//如果能移除返回被删除的value 
public V remove(Object key) {
        Node<K,V> e;
        return (e = removeNode(hash(key), key, null, false, true)) == null ?
            null : e.value;
    }

final Node<K,V> removeNode(int hash, Object key, Object value,
                               boolean matchValue, boolean movable) {
        Node<K,V>[] tab; Node<K,V> p; int n, index;
    	//这里确定数组已经初始化，且长度大于0，且对应的index位置上不是空节点
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (p = tab[index = (n - 1) & hash]) != null) {
            Node<K,V> node = null, e; K k; V v;
            //判断hash值是否相等且（key是否相等 || （key不等于null 且equals相等）,其实就是考虑了如果是整数类型还是其他类型 如果相等直接覆盖，然后返回
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                node = p;
            else if ((e = p.next) != null) {
                //判断是不是红黑树，这里先跳过
                if (p instanceof TreeNode)
                    node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
                else {
                    //判断条件，遍历整个链表，直到找到node结束
                    do {
                        if (e.hash == hash &&
                            ((k = e.key) == key ||
                             (key != null && key.equals(k)))) {
                            node = e;
                            break;
                        }
                        p = e;
                    } while ((e = e.next) != null);
                }
            }
            //这里就是删除节点，然后排序的问题
            if (node != null && (!matchValue || (v = node.value) == value ||
                                 (value != null && value.equals(v)))) {
                //红黑树，后续了解
                if (node instanceof TreeNode)
                    ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
                //这个地方是数组上的节点匹配上了，直接把next放到数组节点上去就可以了
                else if (node == p)
                    tab[index] = node.next;
                //这里是判断如果是链表上的节点，直接把要删除的节点拉上来就可以了
                else
                    p.next = node.next;
                ++modCount;//线程安全的一个值
                --size;
                afterNodeRemoval(node);
                return node;
            }
        }
    	//如果没有找到，直接返回null
        return null;
    }
//以上基于JDK8

6、HsahMap的get方法

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;
    	//根据hash值，找到index，然后一个一个判断是不是是不是相等，如果相等则拿出来返回出去
        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;
    }

 

7、HashMap的遍历

//这没啥东西
 public Set<Map.Entry<K,V>> entrySet() {
        Set<Map.Entry<K,V>> es;
        return (es = entrySet) == null ? (entrySet = new EntrySet()) : es;
    }

final class EntrySet extends AbstractSet<Map.Entry<K,V>> {
        public final int size()                 { return size; }
        public final void clear()               { HashMap.this.clear(); }
        public final Iterator<Map.Entry<K,V>> iterator() {
            return new EntryIterator();
        }
        public final boolean contains(Object o) {
            if (!(o instanceof Map.Entry))
                return false;
            Map.Entry<?,?> e = (Map.Entry<?,?>) o;
            Object key = e.getKey();
            Node<K,V> candidate = getNode(hash(key), key);
            return candidate != null && candidate.equals(e);
        }
        public final boolean remove(Object o) {
            if (o instanceof Map.Entry) {
                Map.Entry<?,?> e = (Map.Entry<?,?>) o;
                Object key = e.getKey();
                Object value = e.getValue();
                return removeNode(hash(key), key, value, true, true) != null;
            }
            return false;
        }
        public final Spliterator<Map.Entry<K,V>> spliterator() {
            return new EntrySpliterator<>(HashMap.this, 0, -1, 0, 0);
        }
        public final void forEach(Consumer<? super Map.Entry<K,V>> action) {
            Node<K,V>[] tab;
            if (action == null)
                throw new NullPointerException();
            if (size > 0 && (tab = table) != null) {
                int mc = modCount;
                for (int i = 0; i < tab.length; ++i) {
                    for (Node<K,V> e = tab[i]; e != null; e = e.next)
                        action.accept(e);
                }
                //此处就是我们在遍历中如果修改了数据会抛出的异常
                if (modCount != mc)
                    throw new ConcurrentModificationException();
            }
        }
    }

 

8、HashMap的hash算法

static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }
//hash 算法
//(h = key.hashCode()) ^ (h >>> 16) 右移16位，采用异或，计算了一下高16位是不会变的，打乱了低16位的值，尽量分散散布在数组上，如果散布在数组上，处理的效率就会快很多
//1011 1000 1000 1000 1000 1000 1000 1000 
//向右移16位
//0000 0000 0000 0000 1011 1000 1000 1000 

//2个值异或
//1011 1000 1000 1000 1000 1000 1000 1000 
//0000 0000 0000 0000 1011 1000 1000 1000
//=====》
//1011 1000 1000 1000 0011 0000 0000 0000

此次阅读HashMap的源码，应该说只涉及到了数据加链表的形式，并没有接触到红黑树

总结：计算机的二进制运算使用不熟悉；

代码的一些风格。比如说有些我们后续不需要使用的对象，我们应该把他置为null

对于代码的精益求精的精神，值得我们学习

代码的设计很重要

 

9、和Hashtable 的比较

• 线程安全** HashMap是线程不安全的，而HashTable是线程安全的，每个人方法通过修饰synchronized来控制线程安全。

• 效率** HashMap比HashTable效率高，原因在于HashTable的方法通过synchronized修饰后，并发的效率会降低

• 允不允许null HashMap运行只有一个key为null，可以有多个null的value。而HashTable不允许key，value为null。

10、和ConcurrentHashMap的比较

 //ConcurrentHashMap这里key和value不能为空
if (key == null || value == null) throw new NullPointerException();

//put方法，链表处理的时候，采用分段锁，而Hashtable基本上所有的方法都用锁了，锁已相对来说效率较HashMap慢一点，但是比Hashtable就会快很多  这个分段锁都是在处理链表的时候加的，为什么？？？？
synchronized (f) {
                    if (tabAt(tab, i) == f) {
                        if (fh >= 0) {
                            binCount = 1;
                            for (Node<K,V> e = f;; ++binCount) {
                                K ek;
                                if (e.hash == hash &&
                                    ((ek = e.key) == key ||
                                     (ek != null && key.equals(ek)))) {
                                    oldVal = e.val;
                                    if (!onlyIfAbsent)
                                        e.val = value;
                                    break;
                                }
                                Node<K,V> pred = e;
                                if ((e = e.next) == null) {
                                    pred.next = new Node<K,V>(hash, key,
                                                              value, null);
                                    break;
                                }
                            }
                        }
                        else if (f instanceof TreeBin) {
                            Node<K,V> p;
                            binCount = 2;
                            if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
                                                           value)) != null) {
                                oldVal = p.val;
                                if (!onlyIfAbsent)
                                    p.val = value;
                            }
                        }
                    }
                }

 

写在最后，个人第一次写博客，刚开始看源码，如果有不正确的地方请指出，在此感谢阅读的你