hashmap_api

Hashmap继承实现的类接口

public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable {}

继承AbstractMap ，实现Cloneable、Serializable接口

AbstractMap

AbstractMap 是 Map 接口的的实现类之一，也是LinkedHashMap , HashMap, TreeMap, ConcurrentHashMap 等类的父类。

AbstractMap 的成员变量

transient volatile Set<K>        keySet;
transient volatile Collection<V> values;

Cloneable

首先，在java中创建对象的方式有四种：
一种是new，通过new关键字在堆中为对象开辟空间，在执行new时，首先会看所要创建的对象的类型，知道了类型，才能知道需 要给这个对象分配多大的内存区域，分配内存后，调用对象的构造函数，填充对象中各个变量的值，将对象初始化，然后通过构造方法返回对象的地址；
另一种是clone，clone也是首先分配内存，这里分配的内存与调用clone方法对象的内存相同，然后将源对象中各个变量的值，填充到新的对象中，填充完成后，clone方法返回一个新的地址，这个新地址的对象与源对象相同，只是地址不同。

另外还有输入输出流，反射构造对象等
浅拷贝：使用一个已知实例对新创建实例的成员变量逐个赋值，这个方式被称为浅拷贝。
深拷贝：当一个类的拷贝构造方法，不仅要复制对象的所有非引用成员变量值，还要为引用类型的成员变量创建新的实例，并且初始化为形式参数实例值。这个方式称为深拷贝（即引用成员变量也要实现Cloneable接口，不然克隆后的引用仍指向同一实例对象）

Serializable

实现该接口才可以序列化，ouputstream

对象的寿命通常随着生成该对象的程序的终止而终止，有时候需要把在内存中的各种对象的状态（也就是实例变量，不是方法）保存下来，并且可以在需要时再将对象恢复。虽然你可以用你自己的各种各样的方法来保存对象的状态，但是Java给你提供一种应该比你自己的好的保存对象状态的机制，那就是序列化。
Java 序列化技术可以使你将一个对象的状态写入一个Byte 流里（系列化），并且可以从其它地方把该Byte 流里的数据读出来（反序列化）。

hash(哈希运算) 一些位运算

这个方法的返回值还是一个哈希值，为了更加均匀

 static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
 }

n = table.length;
index = （n-1） & hash

a亦或b计算 结果为1的几率为1/2,0的几率为1/2 所以，进行亦或计算，得到的结果肯定更为平均，不会偏向0或者偏向1，更为散列

右移16位进行亦或计算，我将其拆分为两部分，前16位的亦或运算，和后16位的亦或运算， 后16位的亦或运算，即原hashcode后16位与原hashcode前16位进行亦或计算，得出的结果，前16位和后16位都有参与其中，保证了 32位全部进行计算。

&	位与	两个比特位都为 1 时，结果才为 1，否则为 0 （位与操作满足交换律和结合律，甚至分配律）
|	位或	两个比特位都为 0 时，结果才为 0，否则为 1 （位或操作满足交换律和结合律，甚至分配律）
~	位非	即按位取反，1 变 0，0 变 1
^	异或	两个比特位相同时（都为 0 或都为 1）为 0，相异为 1（异或操作满足交换律和结合律，甚至分配律。任何整数和自己异或的结果为 0，任何整数与 0 异或值不变）
<<	左移	将所有的二进制位按值向←左移动若干位，左移操作与正负数无关，它只是傻傻地将所有位按值向左移动，高位舍弃，低位补 0
>>	右移	将所有的二进制位按值向右→移动若干位，低位直接舍弃，跟正负无关，而高位补 0 还是补 1 则跟被操作整数的正负相关，正数补 0 ，负数补 1
>>>	无符号右移	将所有的二进制位按值向右→移动若干位，低位直接舍弃，跟正负无关，高位补 0 ，也跟正负无关

判断奇偶数

(n & 1) == 1

省去中间变量交换两整数的值（因为^满足分配率）

public void swap(){
        int a = 1, b = 2;
        a ^= b;
        b ^= a;//b == 1
        a ^= b;//a == 2
        System.out.println("a:" + a);//a:2
        System.out.println("b:" + b);//b:1
    }

变换符号，正变负，负变正

只需对待操作数应用取反操作后再加 1 即可

public void negate(){
        int a = -10, b = 10;
        System.out.println(~a + 1);//10
        System.out.println(~b + 1);//-10
    }

求绝对值

对于负数可以通过上面变换符号的操作得到绝对值， 正数直接返回即可，因此我们要先判断符号位来得知当前数的正负。

public int abs(int a){
        int i = a >> 31;//得到符号位，0 为正数，-1 为负数
        return i == 0 ? a : (~a + 1);//符号位为 0 直接返回，否则返回 ~a + 1
    }
    或者，n>>31 取得n的符号，若n为正数，n>>31等于0，若n为负数，n>>31等于-1 若n为正数 n^0-0 数不变，若n为负数n^-1 需要计算n和-1的补码，异或后再取补码， 结果n变号并且绝对值减1，再减去-1就是绝对值

public int abs(int a){
        return a ^ (a >> 31)) - (a >> 31);
    }

lowbit(获取二进制数字 最低位1 的位置)

负数 补码符号位是1，其它位是对应正数的二进制的取反加一


补码 = 反码 + 1；
lowbit(x) = x & (-x)

构造方法

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;
hashmap数组最小 树化参数
static final int MIN_TREEIFY_CAPACITY = 64;
   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);
    }

返回为2的幂的数，初试的hashmap容量要求。

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;
    }

先来分析有关n位操作部分：先来假设n的二进制为01xxx…xxx。接着
对n右移1位：001xx…xxx，再位或：011xx…xxx
对n右移2为：00011…xxx，再位或：01111…xxx

此时前面已经有四个1了，再右移4位且位或可得8个1
同理，有8个1，右移8位肯定会让后八位也为1。
综上可得，该算法让最高位的1后面的位全变为1。
最后再让结果n+1，即得到了2的整数次幂的值了。
现在回来看看第一条语句：
int n = cap - 1;
　　让cap-1再赋值给n的目的是另找到的目标值大于或等于原值。例如二进制1000，十进制数值为8。如果不对它减1而直接操作，将得到答案10000，即16。显然不是结果。减1后二进制为111，再进行操作则会得到原来的数值1000，即8。

Node节点

static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Node<K,V> next;

        Node(int hash, K key, V value, Node<K,V> next) {
            this.hash = hash;
            this.key = key;
            this.value = value;
            this.next = next;
        }

        public final K getKey()        { return key; }
        public final V getValue()      { return value; }
        public final String toString() { return key + "=" + value; }

        public final int hashCode() {
            return Objects.hashCode(key) ^ Objects.hashCode(value);
        }

        public final V setValue(V newValue) {
            V oldValue = value;
            value = newValue;
            return oldValue;
        }

        public final boolean equals(Object o) {
            if (o == this)
                return true;
            if (o instanceof Map.Entry) {
                Map.Entry<?,?> e = (Map.Entry<?,?>)o;
                if (Objects.equals(key, e.getKey()) &&
                    Objects.equals(value, e.getValue()))
                    return true;
            }
            return false;
        }
    }

putval（插入数据）

     * @param hash hash for key
     * @param key the key
     * @param value the value to put
     * @param onlyIfAbsent if true, don't change existing value
     * @param evict if false, the table is in creation mode.
     * @return previous value, or null if none
 final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        // tab 当前hashmap的散列表
        // p 当前散列表的元素（要插入数据的散列表下标node）
        // n 散列表数组的长度
        // i 路由寻址的位置 也就是插入的位置
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        // 延迟初始化，判定是否初始化散列表，散列表最占内存 可能new不插入数据
        if ((tab = table) == null || (n = tab.length) == 0)
        	// 初次调用建散列表
            n = (tab = resize()).length;
            
        if ((p = tab[i = (n - 1) & hash]) == null)
        	// 获取hash值在散列表的下标，如果改下标没数据，就直接插入
            tab[i] = newNode(hash, key, value, null);
        else {
            //代表要插入的数据所在的位置是有内容的
        	//  e node 临时元素 k 临时的一个key
            Node<K,V> e; K k;
            
            // 表示桶位中的该元素 与要插入的key完全一致，后续需要就直接替换或者不变
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            // 判断node是否是树节点，树节点的插法
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
            	// 如果不是树节点,代表当前是一个链表,那么就遍历链表
                for (int binCount = 0; ; ++binCount) {
                	// 判断是否到达链表的尾部 插入元素，
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        // 链表达到了树化的长度条件
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    // 找到了与插入值key相同的一个元素，
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            // e为空的话，说明直接遍历到空节点并直接创建一个新的节点
            // 如果e不为空，就说明当前节点的key与插入node的key相同 需要替换或者不变。
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

扩容resize()

final来修饰类 方法 属性都表示其值不可变，也就是说类不可继承，方法不可重写，属性不可覆盖。

final Node<K,V>[] resize() {
		// 扩容前的散列表 
        Node<K,V>[] oldTab = table;
        // 扩容前散列表的长度
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        // 扩容前的阈值（触发扩容的数值） capacity
        int oldThr = threshold;
        // 计算出新的tab长度 与新的扩容阈值
        int newCap, newThr = 0;
        
        // oldCap > 0 tab已经初始化过，进行正常的扩容
        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
        }
        // 如果散列表没初始化，oldcap=0 oldthreshold>0 指定了初试oldthreshold
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        // oldcap=0 oldthreshold=0
        else {               // zero initial threshold signifies using defaults
        	// oldThr没有初始化，
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        // 
        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"})
        // 初始化一个长度为newCap的数组newTab，并把table=newTab
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;
        // 本次扩容前 tab 不为null
        if (oldTab != null) {
        	// 遍历tab 可能是单个数据 链表 红黑树 或者空
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> e;
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;
                    // 第一种情况 当前桶位只有一个元素，直接计算出旧node的hash在新散列表所在位置
                    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
                    // 第三种 如果是链表的情况下，则进行下面的链表数据转移的操作 因为新的长度加一了
                    // e.hash & tab.length - 1
                    // tab.length（也就是newCap 增长两倍）长度变化后，最前面那一位可能是0也可能是1 所以要拆成两个链表)
                    // 假设原长度 --> 0b 10000 & hash
                    //  	hash --> 0b 11110 到二倍下标的桶位置
                    //		hash --> 0b 01110 保留在原来的桶位置
                    	// 低位链表
                        Node<K,V> loHead = null, loTail = null;
                        // 高位链表
                        Node<K,V> hiHead = null, hiTail = null;
                        Node<K,V> next;
                        do {
                            next = e.next;
                            // hash -> 
                            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);
                        if (loTail != null) {
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
                        if (hiTail != null) {
                        	// 重新计算出所对应的数组下标值newTab[j + oldCap],存放需要更改数组下标位置的链表头节点
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }

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;
        // 判断tab不为空，查询散列表桶位不为空
        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;
    }

remove

    public boolean remove(Object key, Object value) {
        return removeNode(hash(key), key, value, true, true) != null;
    }
	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;
        // 说明node桶位中有数据。。
        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;
            // 第一种情况 当前桶位 就是你要删除的数据
            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 {
                    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)))) {
                
                // node节点是树类型的   
                if (node instanceof TreeNode)
                    ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
                // 节点为链表形 移除node为首节点
                else if (node == p)
                    tab[index] = node.next;
                else
                    p.next = node.next;
                ++modCount;
                --size;
                afterNodeRemoval(node);
                return node;
            }
        }
        return null;
    }

getOrDefault

// 存在放入原值，不存在放入default
public V getOrDefault(Object key, V defaultValue) {
        Node<K,V> e;
        return (e = getNode(hash(key), key)) == null ? defaultValue : e.value;
    }

遍历hashmap

 abstract class HashIterator {
        Node<K,V> next;        // next entry to return
        Node<K,V> current;     // current entry
        int expectedModCount;  // for fast-fail
        int index;             // current slot

        HashIterator() {
            expectedModCount = modCount;
            Node<K,V>[] t = table;
            current = next = null;
            index = 0;
            if (t != null && size > 0) { // advance to first entry
                do {} while (index < t.length && (next = t[index++]) == null);
            }
        }

        public final boolean hasNext() {
            return next != null;
        }

        final Node<K,V> nextNode() {
            Node<K,V>[] t;
            Node<K,V> e = next;
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            if (e == null)
                throw new NoSuchElementException();
            if ((next = (current = e).next) == null && (t = table) != null) {
                do {} while (index < t.length && (next = t[index++]) == null);
            }
            return e;
        }

        public final void remove() {
            Node<K,V> p = current;
            if (p == null)
                throw new IllegalStateException();
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            current = null;
            K key = p.key;
            removeNode(hash(key), key, null, false, false);
            expectedModCount = modCount;
        }
    }

    final class KeyIterator extends HashIterator
        implements Iterator<K> {
        public final K next() { return nextNode().key; }
    }

    final class ValueIterator extends HashIterator
        implements Iterator<V> {
        public final V next() { return nextNode().value; }
    }

    final class EntryIterator extends HashIterator
        implements Iterator<Map.Entry<K,V>> {
        public final Map.Entry<K,V> next() { return nextNode(); }
    }

// array,set
// 普通for 循环:
// foreach(Interger i :list)
// 



// 获取 value的iterator，然后判断 hasNext(), 取出第一个元素next()
Iterator it = hashmap.values().iterator();
while (it.hasNext()) {
	            value = (Integer) it.next();
	            System.out.println("value:" + value);
	        }
	        
// 获取 key的iterator
Iterator it = hashmap.keys().iterator();
while (it.hasNext()) {
   key = (String) it.next();
   value = (Integer) hMap.get(key);
   System.out.println("key:" + key + "---" + "value:" + value);
}
// 获取entry的iterator
Iterator it = hMap.entrySet().iterator();
while (it.hasNext()) {
       Map.Entry entry = (Map.Entry) it.next();
       key = (String) entry.getKey();
       value = (Integer) entry.getValue();
       System.out.println("key:" + key + "---" + "value:" + value);
   }

为什么HashMap使用红黑树而不使用AVL树

AVL树更加严格平衡，因此可以提供更快的査找效果。因此，对于查找密集型任务使用AVL树没毛病。 但是对于插入密集型任务，红黑树要好一些。
通常，AVL树的旋转比红黑树的旋转更难实现和调试。

在CurrentHashMap中是加锁了的，实际上是读写锁，如果写冲突就会等待，

真正的区别在于在任何添加/删除操作时完成的旋转操作次数。

在AVL树中，从根到任何叶子的最短路径和最长路径之间的差异最多为1。在红黑树中，差异可以是2倍。

两个都给O（log n）查找，但平衡AVL树可能需要O（log n）旋转，而红黑树将需要最多两次旋转使其达到平衡（尽管可能需要检查O（log n）节点以确定旋转的位置）。旋转本身是O（1）操作，因为你只是移动指针。

为什么HashMap使用红黑树而不使用B+树

B和B+树主要用于数据存储在磁盘上的场景，比如数据库索引就是用B+树实现的。这两种数据结构的特点就是树比较矮胖，每个结点存放一个磁盘大小的数据，这样一次可以把一个磁盘的数据读入内存，减少磁盘转动的耗时，提高效率。而红黑树多用于内存中排序，也就是内部排序。

树看重两个性能 插入和查找。插入时有可能要调整树的结构 重新平衡树，B+树 调整树的结构慢一些，所以B+树插入慢，查找快；红黑树插入快 ，查找慢。