和樂

JAVA总结（五）----- 容器（三）-----Map

一、为什么使用Map

二、基于红黑树实现的映射表——TreeMap

1、TreeMap的类声明：

2、TreeMap类字段

3、TreeMap的构造器

3、TreeMap.Entry类

4、TreeMap的实现

三、基于散列表实现的映射表——HashMap

1、HashMap的类声明：

2、HashMap的重要字段

3、HashMap的构造器

4、HashMap的实现

四、双向链表散列的映射表——LinkedHashMap

1、LinkedHahsMap的类声明

2、LinkedHashMap的类字段

3、LinkedHashMap的构造器

4、LinkedHashMap的实现

五、其他Map结构

1、谈java引用

2、WeakHashMap

3、IdentityHashMap

4、ConcuurentHashMap

5、不同Map实现类性能对比。

六、Map与Collection的联系

1、entrySet

2、keySet

3、values

一、为什么使用Map

在前两篇文章中，已经介绍了List与Set。List和Set作为Collection的子接口，提供存储元素的不同策略，并介绍了及其实现的类。但Map并不是作为Collection接口子接口，而是顶级接口（在文章的后面将介绍Map接口与Collection接口的关系）。它提供了另外一种存储策略：映射表。

Map接口：Map采用映射表（或称为关联数组）作为存储元素的基本策略：它维护一组键-值关系，使得我们可以用键来查找值。这种策略使得我们可以由一个对象关联到其他的对象，这无异于是解决许多编程问题的杀手锏。Map接口的实现类很多，比如说：HashMap、TreeMap、LinkedHashMap、WeakHashMap、ConcurrentHashMap、IdentityHashMap等（他们的行为特性各各不相同，这表现在效率、键值对的保存及呈现次序、对象的保存周期、映射表如何在多线程中工作等。）。这也说明了Map接口相比List、Set更加重要。

Map（interface）	Map基于映射表存储策略存储元素，并且对于键值对中的键必须保证其唯一性，所以对于所有存储在Map中的元素必须重写equals方法
HashMap	hashMap基于散列表实现。插入、删除、查询“键值对”的开销的是固定的。可以通过构造器设置容量和负载因子，以调整容器的性能。当容器存储的元素超过某个阀门时将会进行扩容。对插入的键还必须重写hashCode方法
LinkedHashMap	LinkedHashMap类似于HashMap，不同的是每个槽位上的链表采取双向链表实现。因此，取得“键值对”的顺序是其插入次序，或者是最近最少使用（LRU）次序。它的性能稍差于HashMap，但迭代访问时其性能要优于HashMap。对插入的键还必须重写hashCode方法。（维护插入次序）
TreeMap	基于红黑树实现。查看“键”或“键值对”时，它们会被排序（次序由Comparable或者Comparator决定）。TreeMap特点在于：所得到的结果是进过排序的。TreeMap是唯一带有subMap()方法的Map，它可以返回一颗子树。其键必须实现Comparable接口，或者向构造器传递该键定制的Comparator。（维护元素次序。）
WeakHashMap	弱键（Weak key）映射，允许释放映射所指向的对象；如果映射之外没有引用指向某个“键”，则此“键”可以被垃圾收集器回收。
ConcurrentHashMap	线程安全的Map，替代HashTable与synchronizedMap。在线程（2）说过
IdentityHashMap	使用“==”替代equals对“键”比较的散列映射。

二、基于红黑树实现的映射表——TreeMap

在上一章中，我已经介绍过TreeSet存储元素实际上是TreeMap存储。那么现在就介绍TreeMap怎么实现元素的插入、删除、检索操作。

1、TreeMap的类声明：

在TreeMap的类声明中，它实现了NavigableMap接口，实际上是实现了SortedMap接口， SortedMap接口支持按元素的自然顺序（Integer类型为键按照元素的从小到大，String类型为键按照字典序排序）或者根据Comparator指定的排序进行排序，它还支持返回TreeMap的一颗子树或者返回TreeMap的第一个键或者最后一个键。

2、TreeMap类字段

①、comparator字段

comparator字段用于接受定制的排序算法，在put、remove、get方法中均可以通过这个字段进行树的检索。如上图

②、root字段

root字段为Entry类型，Entry为红黑树的结点结构，root代表着该红黑树的根节点。

③、size字段

size字段为该红黑树的结点数量

④、modCount字段

modCount字段和在List的modCount作用是相同的，当进行插入或删除时该值增加或减少。

3、TreeMap的构造器

①、TreeMap的无参构造器

创建一个默认的TreeMap，其中comparator字段为null，表示元素需要实现comparable接口，才能进行比较。若插入的元素没有实现该接口那么将抛出异常“ClassCastException”表明插入的元素无法转换成Comparable类型。

②、TreeMap接收定制Comparator的构造器

此时元素的比较将不会按照元素Comparable接口定义的实现，而是通过传递过来的Comparator进行比较。

③、TreeMap接收Map类型参数填充数据

④、TreeMap根据SortedMap构建类结构

3、TreeMap.Entry类

Entry类构建了红黑树的结点结构。

①、Entry类的类声明

②、Entry类的字段

每一个Entry对象，自动拥有空的子节点链接和一个被设置成BLACK值的color字段。

③、Entry类的构造器

4、TreeMap的实现

在经上面的介绍之后我们已经到TreeMap有一个初步的认识，TreeMap的键要么实现Comparable，要么传递Comparator，用于树的检索。此外Entry类用于构建红黑树的结点。在下面我们将介绍TreeMap的实现：

①、插入

TreeMap类的插入操作是从root开始，它会做以下几件事：

1）如果root为null，检查key值是否为key。以传递进来的key，value构建新结点，root为这个新结点。

2）如果root不为null，定义整型比较变量cmp，当comparator字段不为null时，根据comparator比较key与检索到的结点t.key，若key < t.key，那么往树的左子树搜索（当key与t.key向等时，那么把传递进来的value对结点t的value进行设置）；否则，往右子树搜索。直到找到t为null时。此时依据key、value创建新结点，链接到该树中，再把该结点颜色设置成红色，进入维护红黑树性质方法中（在上一章已经介绍过怎么维护插入时红黑树性质）。

3）此时当comparator为null时，那么根据元素实现的comparable接口进行比较（比较情况也是如步骤（二）类似）。直到找到t为null时。再依据key、value创建新结点，链接到该树中，再把该结点颜色设置成红色，进入维护红黑树性质方法中。

下面是TreeMap插入的源码：

public V put(K key, V value) {
    Entry t = root;
    if (t == null) {
        compare(key, key); // type (and possibly null) check

        root = new Entry<>(key, value, null);
        size = 1;
        modCount++;
        return null;
    }
    int cmp;
    Entry parent;
    // split comparator and comparable paths
    Comparator cpr = comparator;
    if (cpr != null) {
        do {
            parent = t;
            cmp = cpr.compare(key, t.key);
            if (cmp < 0)
                t = t.left;
            else if (cmp > 0)
                t = t.right;
            else
                return t.setValue(value);
        } while (t != null);
    }
    else {
        if (key == null)
            throw new NullPointerException();
        @SuppressWarnings("unchecked")
            Comparable k = (Comparable) key;
        do {
            parent = t;
            cmp = k.compareTo(t.key);
            if (cmp < 0)
                t = t.left;
            else if (cmp > 0)
                t = t.right;
            else
                return t.setValue(value);
        } while (t != null);
    }
    Entry e = new Entry<>(key, value, parent);
    if (cmp < 0)
        parent.left = e;
    else
        parent.right = e;
    fixAfterInsertion(e);
    size++;
    modCount++;
    return null;
}

②、检索

TreeMap的检索同插入操作，将会从root开始：通过Compartor或者元素的Comparable进行比较检索，如下：

1）当Comparator不为空时，那么通过Comparator进行比较。此时获取根结点p，按照传递进来的key，当key < p.key。那么往树的左子树进行检索，否则往右子树。直到key = p.key；或者p为null。当p为null时，则返回的value也为null。

2）当Comparator为空时，那么只能通过元素实现的Comparable进行比较。之后同步骤1）。

下面是TreeMap实现的源码：

public V get(Object key) {
    Entry p = getEntry(key);
    return (p==null ? null : p.value);
}
	 
final Entry getEntry(Object key) {
    // Offload comparator-based version for sake of performance
    if (comparator != null)
        return getEntryUsingComparator(key);
    if (key == null)
        throw new NullPointerException();
    @SuppressWarnings("unchecked")
        Comparable k = (Comparable) key;
    Entry p = root;
    while (p != null) {
        int cmp = k.compareTo(p.key);
        if (cmp < 0)
            p = p.left;
        else if (cmp > 0)
            p = p.right;
        else
            return p;
    }
    return null;
}
	 
final Entry getEntryUsingComparator(Object key) {
    @SuppressWarnings("unchecked")
        K k = (K) key;
    Comparator cpr = comparator;
    if (cpr != null) {
        Entry p = root;
        while (p != null) {
            int cmp = cpr.compare(k, p.key);
            if (cmp < 0)
                p = p.left;
            else if (cmp > 0)
                p = p.right;
            else
                return p;
        }
    }
    return null;
}

③、删除

删除某个结点前，我们需要获取key对应的结点。删除时分为三种情况（在上一章中我已经介绍了）：一是该结点没有左孩子；二是该结点有左孩子，没有右孩子；三是该结点有两个孩子。

1）当该结点没有左孩子时，那么把其右孩子替换到删除结点上

2）当该结点有左孩子没有右孩子时，把左孩子替换到删除结点上

3）当该结点有左右孩子时，那么找该结点的后继元素。如果后继元素为删除结点的右孩子，那么直接把右孩子替换到删除结点。否则，先把后继结点的右孩子替换到删除结点上，然后再把后继结点替换删除结点上。

4）当替换完成后，检查替换结点（情况1、2、3中替换到删除结点的结点）的颜色是否为黑色，如果为黑色那么需要维护红黑性质。（上一章也说明为什么黑色结点就会破坏红黑性质和怎么维护红黑性质）

下面为TreeMap删除的源码：

public V remove(Object key) {
    Entry p = getEntry(key);
    if (p == null)
        return null;

    V oldValue = p.value;
    deleteEntry(p);
    return oldValue;
}

private void deleteEntry(Entry p) {
    modCount++;
    size--;

    // If strictly internal, copy successor's element to p and then make p
    // point to successor.
    if (p.left != null && p.right != null) {
        Entry s = successor(p);
        p.key = s.key;
        p.value = s.value;
        p = s;
    } // p has 2 children

    // Start fixup at replacement node, if it exists.
    Entry replacement = (p.left != null ? p.left : p.right);

    if (replacement != null) {
        // Link replacement to parent
        replacement.parent = p.parent;
        if (p.parent == null)
            root = replacement;
        else if (p == p.parent.left)
            p.parent.left  = replacement;
        else
            p.parent.right = replacement;

        // Null out links so they are OK to use by fixAfterDeletion.
        p.left = p.right = p.parent = null;

        // Fix replacement
        if (p.color == BLACK)
            fixAfterDeletion(replacement);
    } else if (p.parent == null) { // return if we are the only node.
        root = null;
    } else { //  No children. Use self as phantom replacement and unlink.
        if (p.color == BLACK)
            fixAfterDeletion(p);

        if (p.parent != null) {
            if (p == p.parent.left)
                p.parent.left = null;
            else if (p == p.parent.right)
                p.parent.right = null;
            p.parent = null;
        }
    }
}

至此，已经基本介绍了TreeMap的实现（虽然没有说红黑树的操作，但是我上一章已经说得很详细，这里就不赘述）。虽然说了TreeMap维护了元素的次序，但是我认为只有看过源码才能更好的理解它怎么维护。TreeMap是线程不安全的类，在多线程下不应使用它。

此外关于TreeMap怎么实现返回一颗子树，限于水平与时间有限待我以后回顾时再写。

三、基于散列表实现的映射表——HashMap

HashMap是我们最常使用的容器，因为它支持快速检索，而不必维护元素的次序。但是在JDK1.8之后对它有很大的改变。当每个槽位的链表大小超过8时，链表就会转为红黑树（链表的检索实在是没有树快）。

1、HashMap的类声明：

2、HashMap的重要字段

①、table字段

table字段即为散列表，在第一次使用HashMap时将会被初始化，其大小为散列表内置的常量“DEFAULT_INITIAL_CAPACITY”大小，也即为16。散列表的容量必须是2的幂次方，当不是其2的幂次方那么会找最接近于2的幂次方。

②、loadFactor字段

负载因子（load factor）α其值为：表支持存储的元素/表的容量。当负载因子很小的时候，元素存储在同一个槽位上的可能性增加即冲突增加，所以一个好的负载因子应该是最大限度避免冲突。HashMap的默认负载因子大小为常量“DEFAULT_LOAD_FACTOR”即0.75

③、threshold字段

记录当前散列表能支持存储元素的最大值，即散列表的“临界值”。当存储的元素超过该值时那么散列表将会进行扩容。默认值为“DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR”即12。

3、HashMap的构造器

①、HashMap的无参构造器

调用无参构造器时，只有loadFactor字段初始化其值为默认值即0.75，当第一次进行插入时，散列表才会被初始化，此时散列表的容量为16，threshold字段为12。

②、HashMap设定初始化容量的构造器

③、HashMap设置初始化容量和负载因子大小的构造器

调用该构造器时将会检查初始化容量与负载因子是否符合规范。此外当初始化容量不是2的幂次方数时将会进行tableSizeFor操作即搜索最近与初始化容量的2次方数。

4、HashMap的实现

①、容量为什么是2的幂次方

首先我们看看，HashMap怎么找元素的槽位：

通过key的散列码的高位与低位做“异或”运算得到的新的散列值hash，然后在与散列表的容量减一做“与”运算。为什么要这么做？在上一章介绍一个好的散列函数能减少“冲突”现象。那么这么做也是为了进一步减少“冲突”。首先来看看几个例子：

整型值5的散列值为5，那么调用hash方法后，其散列值为：

5的二进制表示： 0000000000000000 000000000000101

5无符号右移16位： 0000000000000000 000000000000000

0000000000000000 0000000000000101 值为5