Java集合之Map

Map接口概述

前边对Java单列集合Collection有了基本的了解，现在开始学习下集合的Map接口。Map是一个非常有用的数据结构，该接口是一个双列集合，所谓双列就是Map是依照键（key）-值（value）对的序列来存储元素，该元素是两个对象，其中的键（key）是唯一的，不能重复，而每个键对应的值（value）则不同，value可以重复。

对于Map这种特点在生活中挺常见的，比如，现在每个人都有一个身份证号码与自己的名字对应，当你在买车票时会直接根据你的身份证号码来搜索具体的人也就是你的名字，而不是通过你的名字来确定身份证号码，为什么不能用名字直接买票呢，相比大家肯定都能正确的回答，即就是生活中存在许许多多同名同姓的人，但是他们的身份证号码却是唯一的，就相当于Map的key，名字就相当于value。

常用的实现类和实现方法

实现类

接下来就看看Map接口的实现类，有好多种实现类，这里主要说说比较常用的几种：

• 1、Hashtable: 
  底层是哈希表数据结构，线程是同步的，不可以存入null键，null值。 
  效率较低，被HashMap 替代。
• 2、HashMap: 
  底层是哈希表数据结构，线程是不同步的，可以存入null键，null值。 
  要保证键的唯一性，需要覆盖hashCode方法，和equals方法。 
  

  LinkedHashMap： 
  该子类基于哈希表又融入了链表。可以Map集合进行增删提高效率。

• 3、TreeMap: 
  底层是二叉树数据结构。可以对map集合中的键进行排序。需要使用Comparable或者Comparator 进行比较排序。return 0，来判断键的唯一性。

Map接口的所有实现类都会有两个标准的构造方法：创建一个空映射的无参构造方法和创建一个与其参数具有相同键值映射关系的新映射

常用的方法

• 1、添加元素： 
      V put(K key, V value): （可以相同的key值，但是添加的value值会覆盖前面的，返回值是前一个，如果没有就返回null） 
      putAll(Map m): 从指定映射中将所有映射关系复制到此映射中（可选操作）。
• 2、删除元素 
      remove() 删除关联对象，指定key对象 
      clear() 清空集合对象
• 3、获取元素 
      value get(key);可以用于判断键是否存在的情况。当指定的键不存在的时候，返回的是null。
• 4、对元素进行判断： 
      boolean isEmpty() 长度为0返回true否则false 
      boolean containsKey(Object key) 判断集合中是否包含指定的key 
      boolean containsValue(Object value) 判断集合中是否包含指定的value
• 5、获取集合长度： 
      Int size（）

了解了Map接口的常用实现类和方法，接下来就可以做一些简单的代码测试了，创建HashMap实现类创建一个对象，使用以上五种常用方法进行测试：

 
 
public class Test{
    public static void main(String[] args) {
        Map<Integer,String> mp = new HashMap<Integer,String>();
        mp.put(1,"aaa");  //添加成功返回null
        mp.put(2,"bbb");
        System.out.println("ccc添加返回值："+mp.put(3,"ccc"));
        //mp.put(test, 3); //这种肯定是会报错的，因为创建mp对象时就已经使用泛型<>指定了键值对的类型为Integer-String
        mp.remove(2);  //根据键key删除元素
        System.out.println(mp);
        String var = mp.get(3);  //键对应的值存在则返回，不存在返回null
        System.out.println("获取键值为3元素的value："+var);
        System.out.println("map集合的长度为："+mp.size());
        boolean bl = mp.isEmpty();
        System.out.println("mp集合是否为空："+bl);
        mp.clear();
        System.out.println("mp集合是否为空："+mp.isEmpty());
    }
}

Map接口实现类的迭代方式

Map接口提供了三种collection视图，允许以键集、值集或者键值对映射关系集来查看集合中的具体元素。对于这三种方式分别对应三个方法实现：

• 1.keySet() 以键集的视图呈现Map集合元素，返回Set集合类型
• 2.values() 值集，返回Collection集合类型
• 3.entrySet() 返回键值映射关系的Set视图（三种方法更多信息请查看API文档）

接下来，通过实例来了解这三种迭代方法；

 
 
//第一种遍历：keySet，键集
Set<Integer> keys = mp.keySet();
Iterator<Integer> sitr = keys.iterator();
while(sitr.hasNext()){
    Integer key = sitr.next();
    System.out.println("mp集合的键为："+key);
    //虽然keySet方法只能获取键集，但还是可以使用get(key)方法获取对应的值
    System.out.println("mp集合的值为："+mp.get(key));
}
//第二种遍历value,这种方法只能迭代集合的值集不能获取到键
Collection<String> values = mp.values();
Iterator<String> citr = values.iterator();
while(citr.hasNext()){
    String str = citr.next();
    System.out.println("集合的值为："+str);
}
//第三种遍历方法：entrySet，键-值对
Set<Map.Entry<Integer,String>> entry = mp.entrySet();
Iterator<Map.Entry<Integer,String>> eitr = entry.iterator();
while(eitr.hasNext()){
    Entry<Integer,String> ee = eitr.next();
    System.out.println("集合的键为："+ee.getKey());
    System.out.println("集合的值为："+ee.getValue());
}
//以上几种在JDK 5后还可以采用for-each循环遍历形式
Map<String, Integer> hashmap = new HashMap<String, Integer>();
for(Map.Entry<String, Integer> map : hashmap.entrySet()){
    System.out.println("key="+map.getKey()+" value="+map.getValue());
}

Map实现类具体分析

HashMap实现类

HashMap实现类内部是基于数据结构哈希表实现，出现于JDK1.2版本，并且可以允许null的键值，是非线程同步的。想要深入学习该实现类，就得先了解哈希表的基本原理。

hash表

大家都知道数据结构数组和链表，数组是查找容易、插入和删除困难；链表则是插入、删除容易，查找困难。而这个哈希表就是集数组和链表结构的优点于一身的一种数据结构。Hash表采用一个映射函数f：key->value将关键字映射到该记录在表中的位置，从而在想要查找该条记录时，可以直接根据关键字和映射关系（Hash函数）计算出其在表中的存储位置（也就是Hash地址）。 
常用的Hash函数构造方法有以下几种： 
1.直接定址法、2.平方取中法、3.折叠法、4.除留取余法 
对于上边四种方法，很容易产生冲突，即就是不同的关键字经过Hash函数处理得到的Hash地址可能一样，造成混乱，因而为了应对这种冲突情况自然有相应的解决方法，比如有：a.开放定址法;b.链地址法 
哈希表有多种这种解决冲突的方法，这里说一种常用的链地址法（拉链法） 

 

如图所示，链地址法可以理解为一个链表的数组形式，左边是数组形式，每个数组的元素是一个链表。具体原理可以这样理解，就是将关键字采用相应的Hash函数（比如除留取余法）处理得到相应的Hash地址，然后在存储空间中寻址若不存在则直接依据数组结构进行存储存储，倘若该Hash地址已存在，则在数据相应Hash地址位开辟一个链表结构一次存储相同的Hash地址。

哈希表的内容还有很多，这里主要就说这么多，明白了这些对于HashMap实现类的原理理解也就容易多了。

HashMap存储原理

先来看看HashMap实现类的默认构造方法，根据参数（容量长度和增长因子）的不通分为以下四种：

 
 
public HashMap()  //采用默认容量（16）和增长因子（0.75）
public HashMap(int initialCapacity)  //指定集合长度
public HashMap(int initialCapacity, float loadFactor) //指定集合长度和增长因子
public HashMap(Map<? extends K, ? extends V> m) // 构造一个映射关系与指定 Map 相同的新 HashMap,容量和增长因子均默认值

容量长度即就是集合的长度空间大小；增长因子是用于在集合空间不够用时增大集合容量的增长率。

 
 
    static final int DEFAULT_INITIAL_CAPACITY = 16;
    static final float DEFAULT_LOAD_FACTOR = 0.75f;
    /**
     * Constructs an empty <tt>HashMap</tt> with the default initial capacity (16) and the default load factor (0.75).
     */
    public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
        table = new Entry[DEFAULT_INITIAL_CAPACITY];
        init();
    }

HashMap类的元素存储主要是使用put方法实现，想要搞清楚其存储原理，就可以从put方法的实现代码中去研究学习。接下来就看看put的实现代码：

 
 
public V put(K key, V value) {
        if (key == null)
            return putForNullKey(value);
        int hash = hash(key.hashCode());
        int i = indexFor(hash, table.length);
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
        modCount++;
        addEntry(hash, key, value, i);
        return null;
    }

如代码所示，往HashMap添加元素的时候，首先会判断key值是否为null，若为空则调用putForNullKey方法:

 
 
private V putForNullKey(V value) {
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            if (e.key == null) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
        modCount++;
        addEntry(0, null, value, 0);
        return null;
    }

将其放置在数组的第一个链表中(for循环table[0])，若存在null则使用新value更新原有value，否则调用addEntry方法；回到上一步，key不为null，调用hash计算键key的哈希表码值，根据hash码值和哈希表table长度计算将其放入数组的第几个链表（也就是数组的索引），此时存在两种情况： 

        情况1：如果算出的位置目前已经存在其他的键key，那么还会调用该键的equals方法与这个位置上的键进行比较，如果equals方法返回的是false，那么该键允许被存储，如果equals方法返回的是true，那么该键被视为重复，不允存储，但是会将该键对应的值value存入，更新旧的value。 

       情况2： 如果算出的位置目前没有任何元素存储，那么该键key可以直接添加到哈希表中，调用addEntry方法:

rehash操作

 
 
void addEntry(int hash, K key, V value, int bucketIndex) {
        if ((size >= threshold) && (null != table[bucketIndex])) {
            resize(2 * table.length);
            hash = (null != key) ? hash(key) : 0;
            bucketIndex = indexFor(hash, table.length);
        }
        createEntry(hash, key, value, bucketIndex);
}

当HashMap集合的大小size大于等于阈值（默认容量16和加载因子0.75的乘机），并且table[bucketIndex]不为null时，就会发生ReHash操作，也就是达到了容量上限需要扩容了，主要发生在resize方法中：

 
 
void resize(int newCapacity) {
        Entry[] oldTable = table;
        int oldCapacity = oldTable.length;
        if (oldCapacity == MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return;
        }
        Entry[] newTable = new Entry[newCapacity];
        boolean oldAltHashing = useAltHashing;
        useAltHashing |= sun.misc.VM.isBooted() &&
                (newCapacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
        boolean rehash = oldAltHashing ^ useAltHashing;
        transfer(newTable, rehash);
        table = newTable;
        threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}

若原来的容量大小已经是MAXIMUM_CAPACITY（2^30），则将阈值threshold设置为整数的最大值Integer.MAX_VALUE((2^31)-1);否则创建一张新表，调用transfer方法将当前表中的所有entries拷贝到新表中。

以上就是HashMap集合的一些基本原理。接下来看看和HashMap类似的HashTable实现类。

HashTable实现类

HashTable实现类是在JDK1.0版本出现的，底层实现同HashMap一样都是基于哈希表的。HashTable不允许null键和值，是线程同步的，在JDK1.2版本时被HashMap取代，两者主要区别就是：线程安全性，同步(synchronization)，以及速度。

在单线程时，由于HashTable是线程安全的，性能肯定是不如HashMap的。而且HashMap的迭代器是快速失败的（fail-fast），当在迭代时有其他线程改变了HashMap的结构（增加或移除元素，除过迭代器本身的remove方法），就会抛出ConsurrentModificationException异常。

对于HashMap不是线程安全的，在JDK 5时加入了ConcurrentHashMap，可以支持多个并发线程。

TreeMap实现类

HashMap实现类底层是基于哈希表数据结构实现（可以理解为数组和链表的合体）。而TreeMap实现类底层是基于红黑树（二叉树）数据结构实现的，往TreeMap添加元素的时候，如果元素的键具备自然顺序或者创建映射时提供了Comparator接口，那么就会按照键的这两种特性进行排序存储。 
基于树实现必然会牵扯到左右子树节点的定义，下来先看看TreeMap类的节点是如何定义的：

 
 
static final class Entry<K,V> implements Map.Entry<K,V> {
        K key;
        V value;
        Entry<K,V> left = null; //左子树
        Entry<K,V> right = null;  //右子树
        Entry<K,V> parent;  //父节点
        boolean color = BLACK;
        Entry(K key, V value, Entry<K,V> parent) {
            this.key = key;
            this.value = value;
            this.parent = parent;
        }
        public K getKey() {
            return key;
        }
        /**
         * Returns the value associated with the key
         * @return the value associated with the key
         */
        public V getValue() {
            return value;
        }
        /**
         * 该方法功能是当新插入的节点的key和当前节点的key相等时，会
         * 以新插入key对应的value1更新当前节点key对应的value2，然后将该value2返回
         */
        public V setValue(V value) {
            V oldValue = this.value;
            this.value = value;
            return oldValue;
        }
        public boolean equals(Object o) {
            if (!(o instanceof Map.Entry))
                return false;
            Map.Entry<?,?> e = (Map.Entry<?,?>)o;
            return valEquals(key,e.getKey()) && valEquals(value,e.getValue());
        }
        public int hashCode() {
            int keyHash = (key==null ? 0 : key.hashCode());
            int valueHash = (value==null ? 0 : value.hashCode());
            return keyHash ^ valueHash;
        }
        public String toString() {
            return key + "=" + value;
        }
    }

TreeMap实现的对象中添加节点信息，如果插入的节点的键key已存在，则会更新旧键的value值，并返回被替换的value，否则put方法返回null

 
 
 
   
   
 public V put(K key, V value) {
 Entry<K,V> 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<K,V> parent;
 // split comparator and comparable paths
 Comparator<? super K> cpr = comparator;
 if (cpr != null) { //Comparator比较器不为空
 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); //键已存在，更新value值
 } while (t != null);
 }
 else {//比较器为空，采用Comparable接口的comparaTo方法比较
 if (key == null)
 throw new NullPointerException();
 Comparable<? super K> k = (Comparable<? super K>) key;
 do {
 parent = t;
 cmp = k.compareTo(t.key); 
 if (cmp < 0) //当前key大于插入key，继续遍历左子树
 t = t.left;
 else if (cmp > 0) //当前key小于插入key，遍历右子树
 t = t.right;
 else
 return t.setValue(value);
 } while (t != null);
 }
 //将所有子树全部遍历为空后（即就是到叶子节点），则将插入节点作为parent的子节点
 Entry<K,V> e = new Entry<>(key, value, parent);
 if (cmp < 0)
 parent.left = e;
 else
 parent.right = e;
 fixAfterInsertion(e); //插入新节点，调用fixAfterInsertion方法调整红黑树
 size++;
 modCount++;
 return null;
 }

fixAfterInsertion方法调整红黑树主要由三个方法setColor（设置颜色）rotateLeft（左旋）、rotateRight（右旋）实现，这也是红黑树的核心操作，对于这部分更为详细的介绍可以参看文章http://www.cnblogs.com/chenssy/p/3746600.html。 

TreeMap添加不具备自然顺序的元素和自定义Comparator接口 
接下来看看测试代码，继续深入了解下，键值对象不具有自然顺序时，键所属的类没有实现Comparable接口，也没有在创建TreeMap对象的时候传入比较器时，运行代码时就会报错:

 
 
class staff{ 
    int id;
    String name;
    staff(int id,String name) {
        super();
        this.id = id;
        this.name = name;
    }
    @Override
    public String toString() {
        return "["+this.id+","+this.name+"]";
    }
}
public class TreeMap_test {
    public static void main(final String[] args) {
        Map<staff,String> map = new TreeMap<staff,String>();
        map.put(new staff(2,"张三"), "语文");
        map.put(new staff(1,"李四"), "数学");
        map.put(new staff(5,"王五"), "英语");
        System.out.println(map);
    }
}

程序中因为键值是自定义staff的类型，并没有自然顺序，在输入键值时调用默认的compare方法就无法进行比较，因而运行程序时会报错如下：

 
 
Exception in thread "main" java.lang.ClassCastException: staff cannot be cast to java.lang.Comparable
    at java.util.TreeMap.compare(Unknown Source)
    at java.util.TreeMap.put(Unknown Source)
    at TreeMap_test.main(TreeMap_test.java:25)

因而在使用TreeMap添加元素时应该注意如下两点：

• 1.往TreeMap添加元素的时候，如果元素的键不具备自然顺序特性， 那么键所属的类必须要实现Comparable接口，把键的比较规则定义在CompareTo方法上;
• 2.往TreeMap添加元素的时候，如果元素的键不具备自然顺序特性，而且键所属的类也没有实现Comparable接口，那么就必须在创建TreeMap对象的时候传入比较器。

 
 
//1.键所属的类实现Comparable接口
class staff implements Comparable<staff>{
    @Override
    public int compareTo(staff o) {
        return this.id-o.id;
    }
}
//2.自定义Comparator接口，在创建TreeMap对象时传入比较器
class Mycomparetor implements Comparator<staff> {
    @Override
    public int compare(staff o1,staff o2) {
        return o1.id - o2.id;
    }
}
public class TreeMap_test {
    public static void main(final String[] args) {
        Mycomparetor comparetor = new Mycomparetor();
        Map<staff,String> map = new TreeMap<staff,String>(comparetor);
    }
}

运行程序就会按键中的id排序：

 
 
{[1,李四]=数学, [2,张三]=语文, [5,王五]=英语}

以上就是自己学习Java集合之Map接口的一些总结，虽说不是很深入，但是从不懂到编写基本的集合代码肯定没有问题，后边还得继续加油。。。