Java基础之集合Map

Map

1. HashMap 是根据数组加单向链表来实现的

2. 数组中存储的就是Node对象

链表节点类

    // hash 哈希值
    // key key信息
    // value value信息
    // next 下一个节点
    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;
        }
    }

put流程

1. 调用put(key,value) 方法像map里添加数据
2. 根据key生成hashcode，根据hashcode，key,value来创建创建Node节点对象
3. hashcode和（数组大小（默认初始16）-1）根据‘&’运算得到数组下标位置。所以HashMap是无序的

// 源码629行
 if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);

4. 如果此下标位置上已经存在Node对象。则根据使用链表绑定。（此下标下最后一个节点的next属性指向此节点的地址）。key的hashcode一致则覆盖。

// 源码 641行
  p.next = newNode(hash, key, value, null);

5. 当数组使用率超过（数组大小*负载因子）时，数组扩容一倍。并数组下的Node节点重新排位。

get流程

1. 调用get(key)方法
2. 根据key生成hashcode，hashcode和（数组大小（默认初始16）-1）根据‘&’运算得到数组下标位置。
3. 根据下标得到数组下的Node节点对象

// 源码568行
 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;

4. 如果此节点的key不是我们想要的key,那么根据此节点next属性向下查找，一致查找到对的Node节点
5. 返回此节点的value值

HashMap 和 HashTable 有这样几个属性

threshold：数组大小乘以负载因子得到的值

loadFactor ：负载因子（默认0.75）

size： 数组使用率

1. 数组容量默认16
2. 负载因子默认0.75
3. threshold 等于 数组容量乘以负载因子，默认（16 * 0.75 = 12）。
4. 当put() 时， size 大于 threshold，数组扩容，扩容为 （原容量 << 1）
5. 也就是说：（默认）当size大于12时，数组进行扩容至32，threshold变成24。当size大于24时,数组扩容至64，threshold变成48。

HashMap和HashTable有什么区别

1、HashMap是非线程安全的，HashTable的操作方法都被synchronized修饰所以是线程安全的。

2、HashMap的键和值都允许有null值存在，而HashTable则不行。

3、因为线程安全的问题，HashMap效率比HashTable的要高。

LinkedHashMap

LinkedHashMap里的属性

// 第一个(第一个添加的对象的引用)
transient LinkedHashMap.Entry<K,V> head;
// 最后一个(最后一个添加的对象的引用)
transient LinkedHashMap.Entry<K,V> tail;

1. LinkedHashMap是集成HashMap实现的
2. LinkedHashMap 重写了 HashMap的newNode方法，此方法重新创建了node节点。新创建的node节点继承了HashMap的Node的类，额外还拥有的before（上一个） 和 after（下一个）。而这两个属性保证了Map的有序性（双向链表）。

实现过程

1. 当LinkedHashMap调用put(key,value) 时，会创建Node对象，LinkedHashMap重写了newNode()和Node类。当创建Node时。

2. 如果是第一次put就将Node的地址分别赋给head和tail第二次put时，tail（前一个节点对象） 的 after的值设置为当前创建的对象。当前的对象的before设置为tail（前一个节点对象），tail的地址在指向当前节点对象。详细信息看下面代码

    private void linkNodeLast(LinkedHashMap.Entry<K,V> p) {
        LinkedHashMap.Entry<K,V> last = tail;
        tail = p;
        if (last == null)
            head = p;
        else {
            p.before = last;
            last.after = p;
        }
    }

这样LinkedHashMap 相当于是一个双向链表和HashMap的结合

Map的遍历

Map<String,String> map = new HashMap<>();
    map.put("name","刘志强");
    map.put("age","24");
        
    map.forEach((k,v)-> System.out.println(k + ":" + v));
    // 或者（jdk1.8生效）
    Set<Map.Entry<String, String>> set =  map.entrySet();

    
    Iterator<Map.Entry<String, String>> value = set.iterator();
    while (value.hasNext()) {
        Map.Entry s = value.next();
        System.out.println(s.getKey() + ":" + s.getValue());
    }

TreeMap

TreeMap中的元素默认按照keys的自然排序排列。

（对Integer来说，其自然排序就是数字的升序；对String来说，其自然排序就是按照字母表排序）