Java提升篇（三三）-----Map总结

时间 2019-11-20

标签 java 提升三三 map 总结栏目 Java 繁體版

原文原文链接

在前面LZ详细介绍了HashMap、HashTable、TreeMap的实现方法，从数据结构、实现原理、源码分析三个方面进行阐述，对这个三个类应该有了比较清晰的了解,下面LZ就Map作一个简单的总结。html

1、Map概述

首先先看Map的结构示意图源码分析

Map：“键值”对映射的抽象接口。该映射不包括重复的键，一个键对应一个值。性能

SortedMap：有序的键值对接口，继承Map接口。优化

NavigableMap：继承SortedMap，具备了针对给定搜索目标返回最接近匹配项的导航方法的接口。this

AbstractMap：实现了Map中的绝大部分函数接口。它减小了“Map的实现类”的重复编码。

Dictionary：任何可将键映射到相应值的类的抽象父类。目前被Map接口取代。

TreeMap：有序散列表，实现SortedMap 接口，底层经过红黑树实现。

HashMap：是基于“拉链法”实现的散列表。底层采用“数组+链表”实现。

WeakHashMap：基于“拉链法”实现的散列表。

HashTable：基于“拉链法”实现的散列表。

总结以下：

他们之间的区别：

2、内部哈希：哈希映射技术

几乎全部通用Map都使用哈希映射技术。对于咱们程序员来讲咱们必需要对其有所了解。

哈希映射技术是一种就元素映射到数组的很是简单的技术。因为哈希映射采用的是数组结果，那么必然存在一中用于肯定任意键访问数组的索引机制，该机制可以提供一个小于数组大小的整数，咱们将该机制称之为哈希函数。在Java中咱们没必要为寻找这样的整数而大伤脑筋，由于每一个对象都一定存在一个返回整数值的hashCode方法，而咱们须要作的就是将其转换为整数，而后再将该值除以数组大小取余便可。以下

int hashValue = Maths.abs(obj.hashCode()) % size;

下面是HashMap、HashTable的：

----------HashMap------------
//计算hash值
static int hash(int h) {
    h ^= (h >>> 20) ^ (h >>> 12);
    return h ^ (h >>> 7) ^ (h >>> 4);
}
//计算key的索引位置
static int indexFor(int h, int length) {
        return h & (length-1);
}
-----HashTable--------------
int index = (hash & 0x7FFFFFFF) % tab.length;     //确认该key的索引位置

 位置的索引就表明了该节点在数组中的位置。下图是哈希映射的基本原理图：

在该图中1-4步骤是找到该元素在数组中位置，5-8步骤是将该元素插入数组中。在插入的过程当中会遇到一点点小挫折。在众多肯能存在多个元素他们的hash值是同样的，这样就会获得相同的索引位置，也就说多个元素会映射到相同的位置，这个过程咱们称之为“冲突”。解决冲突的办法就是在索引位置处插入一个连接列表，并简单地将元素添加到此连接列表。固然也不是简单的插入，在HashMap中的处理过程以下：获取索引位置的链表，若是该链表为null，则将该元素直接插入，不然经过比较是否存在与该key相同的key，若存在则覆盖原来key的value并返回旧值，不然将该元素保存在链头（最早保存的元素放在链尾）。下面是HashMap的put方法，该方法详细展现了计算索引位置，将元素插入到适当的位置的所有过程：

public V put(K key, V value) {
        //当key为null，调用putForNullKey方法，保存null与table第一个位置中，这是HashMap容许为null的缘由
        if (key == null)
            return putForNullKey(value);
        //计算key的hash值
        int hash = hash(key.hashCode());                 
        //计算key hash 值在 table 数组中的位置
        int i = indexFor(hash, table.length);            
        //从i出开始迭代 e,判断是否存在相同的key
        for (Entry<K, V> e = table[i]; e != null; e = e.next) {
            Object k;
            //判断该条链上是否有hash值相同的(key相同)
            //若存在相同，则直接覆盖value，返回旧value
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;    //旧值 = 新值
                e.value = value;
                e.recordAccess(this);
                return oldValue;     //返回旧值
            }
        }
        //修改次数增长1
        modCount++;
        //将key、value添加至i位置处
        addEntry(hash, key, value, i);
        return null;
    }

HashMap的put方法展现了哈希映射的基本思想，其实若是咱们查看其它的Map，发现其原理都差很少！

3、Map优化

首先咱们这样假设，假设哈希映射的内部数组的大小只有1，全部的元素都将映射该位置（0），从而构成一条较长的链表。因为咱们更新、访问都要对这条链表进行线性搜索，这样势必会下降效率。咱们假设，若是存在一个很是大数组，每一个位置链表处都只有一个元素，在进行访问时计算其 index 值就会得到该对象，这样作虽然会提升咱们搜索的效率，可是它浪费了控件。诚然，虽然这两种方式都是极端的，可是它给咱们提供了一种优化思路：使用一个较大的数组让元素可以均匀分布。在Map有两个会影响到其效率，一是容器的初始化大小、二是负载因子。

3.一、调整实现大小

在哈希映射表中，内部数组中的每一个位置称做“存储桶”(bucket)，而可用的存储桶数（即内部数组的大小）称做容量 (capacity)，咱们为了使Map对象可以有效地处理任意数的元素，将Map设计成能够调整自身的大小。咱们知道当Map中的元素达到必定量的时候就会调整容器自身的大小，可是这个调整大小的过程其开销是很是大的。调整大小须要将原来全部的元素插入到新数组中。咱们知道index = hash(key) % length。这样可能会致使原先冲突的键不在冲突，不冲突的键如今冲突的，从新计算、调整、插入的过程开销是很是大的，效率也比较低下。因此，若是咱们开始知道Map的预期大小值，将Map调整的足够大，则能够大大减小甚至不须要从新调整大小，这颇有可能会提升速度。下面是HashMap调整容器大小的过程，经过下面的代码咱们能够看到其扩容过程的复杂性：

void resize(int newCapacity) {
            Entry[] oldTable = table;    //原始容器
            int oldCapacity = oldTable.length;    //原始容器大小
            if (oldCapacity == MAXIMUM_CAPACITY) {     //是否超过最大值：1073741824
                threshold = Integer.MAX_VALUE;
                return;
            }

            //新的数组：大小为 oldCapacity * 2
            Entry[] newTable = new Entry[newCapacity];    
            transfer(newTable, initHashSeedAsNeeded(newCapacity));
            table = newTable;
           /*
            * 从新计算阀值 =  newCapacity * loadFactor >  MAXIMUM_CAPACITY + 1 ? 
            *                         newCapacity * loadFactor :MAXIMUM_CAPACITY + 1
            */
            threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);   
        }
        
        //将元素插入到新数组中
        void transfer(Entry[] newTable, boolean rehash) {
            int newCapacity = newTable.length;
            for (Entry<K,V> e : table) {
                while(null != e) {
                    Entry<K,V> next = e.next;
                    if (rehash) {
                        e.hash = null == e.key ? 0 : hash(e.key);
                    }
                    int i = indexFor(e.hash, newCapacity);
                    e.next = newTable[i];
                    newTable[i] = e;
                    e = next;
                }
            }
        }

3.二、负载因子

为了确认什么时候须要调整Map容器，Map使用了一个额外的参数而且粗略计算存储容器的密度。在Map调整大小以前，使用”负载因子”来指示Map将会承担的“负载量”，也就是它的负载程度，当容器中元素的数量达到了这个“负载量”，则Map将会进行扩容操做。负载因子、容量、Map大小之间的关系以下：负载因子 * 容量 > map大小 ----->调整Map大小。

例如：若是负载因子大小为0.75（HashMap的默认值），默认容量为11，则 11 * 0.75 = 8.25 = 8，因此当咱们容器中插入第八个元素的时候，Map就会调整大小。

负载因子自己就是在控件和时间之间的折衷。当我使用较小的负载因子时，虽然下降了冲突的可能性，使得单个链表的长度减少了，加快了访问和更新的速度，可是它占用了更多的控件，使得数组中的大部分控件没有获得利用，元素分布比较稀疏，同时因为Map频繁的调整大小，可能会下降性能。可是若是负载因子过大，会使得元素分布比较紧凑，致使产生冲突的可能性加大，从而访问、更新速度较慢。因此咱们通常推荐不更改负载因子的值，采用默认值0.75.