2020-12-02

Map容器

​ Map是以键和值的形式保存元素，Map也叫做映射表，通过键映射值，从容器中拿值和在容器中放值都通过键来操作，这个键就是值的唯一标识。

​ Map容器没有角标。

Map中的方法

1、size() : int 计算Map中有多少个键值对。

2、isEmpty(Object) : boolean 判断Map是否为空。

3、containsKey(Object) : boolean 判断Map所有的内容中包不包含这个Object型键的键值对。

4、containsValue(Object) : boolean 判断Map所有内容中包不包含这个Object型的值。

5、get(Object) : V 括号中Object的参数指的是K的值，也就是键的值，get方法就是通过键的值获得这个键所对应的Value的值。

6、put(K , V) : V 将键值对放入Map中。

7、remove(Object) : V 删除某一个键值对，括号中传的是键。

8、putAll(Map < ? extends K , ? extends V >) : void 将别的Map中的所有键值对一起放入这个Map中。

9、clear() : void 将Map中所有的键值对删除。

10、keySet() : Set 将Map容器中的所有K值放入Set中，通过遍历Set拿出Map中所有的value值。

11、values() : Collection

12、entrySet() : Set<Entry<K,V>> 将Map容器中的每一个键值对放入Set中，通过迭代遍历Set拿出Map中的所有元素。

Entry<K,V>

​ Entry代表单一一条键值对。

HashMap<K,V>

创建HashMap对象、求长定位替换：

HashMap<String,Integer> map = new HashMap<>();
map.put("nihao",90);
map.put(null,89);//null值可以作为键值对的K值和V值
map.put("a",null);
map.put(null,null);//Map容器中可以放入null值
System.out.println(map.get("nihao"));
System.out.println(map.get("bbb"));//当get的键值在容器中不存在是，返回的值是null
map.put("nihao",77);//容器中的键值是唯一的，当放入的值是同一个键值时，value值会被替换掉
map.replace("nihao",55);//替换“nihao”这个键值对应的value值的
map.remove("nihao");//删掉“nihao”这个键值对。
 

纵切遍历Map

​ 调用keySet()方法先将Map容器中的所有key值放入Set容器，再通过迭代器获取key值实现遍历Map容器。

Set<String> keys = map.keySet();
for(String k : keys){
    System.out.prinln(k + ":" + map.get(k));
}

横切遍历Map

​ 调用Entry(K,V)方法先将Map容器中一个一个的键值对放入Set容器中，通过迭代器遍历Set容器，使用Entry中的getKey()和getValue()方法获得Map中每一个键值对。

Set<Entry<K,V>> entrySets = map.entrySet();
for(Entry<K,V> node : entrySets){
    System.out.println(node.getKey() + ":" + node.getValue());
}

HashMap底层源码

​ HashMap底层是由数组加链表的形式，拉链法来保存数据，插入值使用尾插法。

源码

​ 默认的初始容量为16。

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

​ 默认加载因子为0.75。加载因子的作用是：当放入容器的值达到当前容器容量的0.75倍时，容器就需要扩容。扩容1倍，这样简化rehash的过程。

static final float DEFAULT_LOAD_FACTOR = 0.75f;

​ 树化因子为8，当链表节点超过8个的时候，会优化为一种查找树。

static final int TREEIFY_THRESHOLD = 8;

​ 转化为链表，大小为6。

static final int UNTREEIFY_THRESHOLD = 6;

​ 转化为树时，最小容量为64。

static final int MIN_TREEIFY_CAPACITY = 64;

​ HashMap的构造方法，再HashMap中，底层的拉链数组是一个Node<K,V>节点数组，这个数组叫table。

​ 创建HashMap对象是，加载因子的大小位默认初始大小位0.75。

public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }

​ Node类是当要向Map容器中放值时，就创建一个Node对象来放入值。

​ Node里记录了一个key，一个value，一个next，没有prev，所以Node可以变成链表，但不是双向链表，是一个单向链表，用尾插的形式插入数据。

static class Node<K,V> implements Map.Entry<K,V> {//Map中每一个元素都是一个node节点。
        final int hash;//这个hash值时key的hashCode值异或value的hashCode值
        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) {//改变节点中的value值
            V oldValue = value;
            value = newValue;
            return oldValue;
        }

        public final boolean equals(Object o) {//判断两个值是否相等
            if (o == this)//比较两个值的内存地址是否相等
                return true;
            if (o instanceof Map.Entry) {//判断o是不是Entry
                Map.Entry<?,?> e = (Map.Entry<?,?>)o;//将o这个类型强制转换为Entry型
                if (Objects.equals(key, e.getKey()) &&
                    Objects.equals(value, e.getValue()))
                    return true;
            }
            return false;
        }
    }

​ 通过key值计算hash值。这个hash值的作用是确定这个元素应该放在哪个位置上。

​ hash的计算过程：如果对象为null就将这个值放入0这个位置，如果不为null，就将key的hashCode值向右移16位，高位补0。将key的hashCode值和移位后的值进行异或，得到放置的位置。也就是将key的hashCode值的高位和地位进行异或得到新的hashCode的低位，新的hashCode的低位不变。

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

​ HashMap底层是由hash散列表实现的，hash散列表是由拉链法实现，拉链法首先需要一个数组， 在HashMap中这个数组叫table，是一个Node<K,V>型的数组。

transient Node<K,V>[] table;

int threshold;//转化因子，用来树化的
final float loadFactor;//加载因子，用来扩容的

put(K,V)过程

​ HashMap中使用put()方法放入一个元素，put()方法会调用putVal()这个方法。

public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }

putVal()方法

​ putVal()中的hash值等于key的hashCode值的高位与低位进行异或，高位不变。

​ onlyIfAbsent为false时，不管容器中有没有这个值，都将这个值放入容器中；为true时，容器中有这个值，这个值就不能放入容器中。

​ evict为true时，就替换掉容器中原来的值。

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)//如果table为null或者table的长度为0，就调用resize()方法给table重新赋值长度
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)//计算应该将值放在哪个位置，如果这个位置为空，就将这个值放入该位置,(n-1) & hash就是hash值对table长度的大小取余。
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            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);
            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;
                    }
                    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;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

resize()方法

final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table;
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    int oldThr = threshold;
    int newCap, newThr = 0;
    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);
    }
    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;
    if (oldTab != null) {
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
            if ((e = oldTab[j]) != null) {
                oldTab[j] = null;
                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;
                        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) {
                        hiTail.next = null;
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}

第一次向Map容器中put一个值时

1、put()方法调用putVal()方法，判断table为空，table = resize()。

2、然后调用resize()方法，第一次向容器中放值，容器容量和 转化因子都等于0，原来的容器容量就变为初始容量值为16。转化因子等于初始的加载因子0.75乘以初始的容量16，转化因子变为12。

​ 也就是说，当创建一个HashMap对象，向容器中放入第一个值时，容器的初始化大小为16，转化因子为12。