Java 之 Map 接口

一、Map 接口概述

　　java.util.Map 接口专门用来存放键值对这种对象关系的对象。

　　下面比较一下 Collection 与 Map 的区别：

• • 　Collection 中的集合，元素是孤立存在的（理解是为单身），向集合存储元素采用一个个元素的方式存储。
  • Map 中的集合，元素是成对存在的（理解为夫妻）。每个元素由键与值两部分组成，通过键可以找到所对应的值。
  • Collection 中的集合称为 单列集合，Map 中的集合称为双列集合。
  • 注意：Map 中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。

　　　 Map 集合的特点：

　　　　1. Map 集合是一个双列集合，一个元素包含两个值（一个 key,一个 value）

　　　　2. Map 集合中的元素，key 和 value 的数据类型可以相同，也可以不同

　　　　3. Map 集合中的元素，key 是不允许重复的，value 是可以重复的

　　　　4. Map 集合中的元素，key 和 value 是 一一对应

　　　　注意：Map接口中的集合都有两个泛型变量,在使用时，要为两个泛型变量赋予数据类型。两个泛型变量的数据类型可以相同，也可以不同。

二、Map 接口中常用方法

　　常用方法：

public V  put(K key,V value)：把指定的键与指定的值添加到Map集合中
public void putAll(Map m):从指定映射中将所有映射关系复制到此映射中
public V remove(Object key)：把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值
public V get（Object key）：根据指定的键，在 Map 集合中获取对应的值
boolean containsKey(Object key) ：是否包含某个key
boolean containsValue(Object value) ：是否包含某个value
boolean isEmpty()：是否为空
void clear():从此映射中移除所有映射关系
int size():返回此映射中的键-值映射关系数
public Set<K> keySet():获取 Map 集合中所有的键，存储到 Set 集合中
Collection<V> values():返回此映射中包含的值的 Collection 视图
public Set<Map.Entry<K,V>> entrySet() : 获取到Map集合中所有的键值对对象的集合(Set集合)。 

　　　　方法详解：

　　　　1、get() 方法

 public V get(Object key) 根据指定的键，在Map集合中获取对应的值。
            返回值:
                key存在,返回对应的value值
                key不存在,返回null

　　　　2、containsKey() 方法

 boolean containsKey(Object key) 判断集合中是否包含指定的键。
        包含返回true,不包含返回false

　　　 3、remove() 方法

public V remove(Object key): 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。
            返回值:V
                key存在,v返回被删除的值
                key不存在,v返回null

　　　4、put() 方法

 public V put(K key, V value):  把指定的键与指定的值添加到Map集合中。
            返回值:v
                存储键值对的时候,key不重复,返回值V是null
                存储键值对的时候,key重复,会使用新的value替换map中重复的value,返回被替换的value值

　　

三、Map 集合遍历方法

　　1、通过 键找值 的方式

　　　　Map 集合中的方法：Set<K> keySet() 返回此映射中包含的键的 Set 视图。

　　　　这里所有的key组成了一个Set集合，因为它们不可重复

　　　　实现步骤：

　　　　　　（1）使用 Map 集合中的方法 keySet()，把 Map 集合所有的 key 取出来，存储到一个 set 集合中

　　　　　　（2）通过 set 集合，获取 Map 集合中的每一个 key

　　　　　　（3）通过 Map 集合中的方法 get(key)，通过 key 找到 value。

　　　　 Demo：

 public static void main(String[] args) {
         //创建Map集合对象
         Map<String,Integer> map = new HashMap<>();
         map.put("赵丽颖",168);
         map.put("杨颖",165);
         map.put("林志玲",178);

         //1.使用Map集合中的方法keySet(),把Map集合所有的key取出来,存储到一个Set集合中
         Set<String> set = map.keySet();

         //2.遍历set集合,获取Map集合中的每一个key
         //使用迭代器遍历Set集合
         Iterator<String> it = set.iterator();
         while (it.hasNext()){
             String key = it.next();
             //3.通过Map集合中的方法get(key),通过key找到value
             Integer value = map.get(key);
             System.out.println(key+"="+value);
         }
         System.out.println("-------------------");
         //使用增强for遍历Set集合
         for(String key : set){
             //3.通过Map集合中的方法get(key),通过key找到value
             Integer value = map.get(key);
             System.out.println(key+"="+value);
         }
         System.out.println("-------------------");
         //使用增强for遍历Set集合
         for(String key : map.keySet()){
             //3.通过Map集合中的方法get(key),通过key找到value
             Integer value = map.get(key);
             System.out.println(key+"="+value);
         }
     }

　　2、通过 值 遍历

　　　　Map 接口中的方法 Collection values():获取所有的 value，然后遍历它们。

　　　　这里所有的value组成了一个Collection系列的集合，可能重复，也可能不重复

　　　　　Demo：

 @Test
 public void test06(){
     Map map = new HashMap();

     map.put("张三", 175);
     map.put("李四", 172);
     map.put("王五", 178);
     map.put("赵六", 182);

     Collection values = map.values();
     for (Object value : values) {
         System.out.println(value);
     }

 }

　　3、使用 Entry 对象遍历

　　　　Map 中存放的是两种对象，一种称为 key(键)，一种称为 value(值)，它们在在 Map 中是一一对应关系，这一对对象又称做 Map 中的一个 Entry(项) 。

　　　　因为key不可重复，那么所有的组合也就唯一了，所以所有的映射关系也是set集合。

　　　　

　　　　Entry 将键值对的对应关系封装成了对象。即键值对对象，这样我们在遍历 Map 集合时，就可以从每一个键值对（ Entry ）对象中获取对应的键与对应的值。

　　　　既然Entry表示了一对键和值，那么也同样提供了获取对应键和对应值得方法：

public K getKey() ：获取Entry对象中的键。
public V getValue() ：获取Entry对象中的值。

　　      Map集合中的方法:　

Set<Map.Entry<K,V>> entrySet()   返回此映射中包含的映射关系的 Set 视图。

　　     实现步骤：

　　　　（1）使用Map集合中的方法entrySet(),把Map集合中多个Entry对象取出来,存储到一个Set集合中

　　　　（2）遍历Set集合,获取每一个Entry对象

　　　　（3）使用Entry对象中的方法getKey()和getValue()获取键与值

　　　Demo：

 public static void main(String[] args) {
         //创建Map集合对象
         Map<String,Integer> map = new HashMap<>();
         map.put("赵丽颖",168);
         map.put("杨颖",165);
         map.put("林志玲",178);

         //1.使用Map集合中的方法entrySet(),把Map集合中多个Entry对象取出来,存储到一个Set集合中
         Set<Map.Entry<String, Integer>> set = map.entrySet();

         //2.遍历Set集合,获取每一个Entry对象
         //使用迭代器遍历Set集合
         Iterator<Map.Entry<String, Integer>> it = set.iterator();
         while(it.hasNext()){
             Map.Entry<String, Integer> entry = it.next();
             //3.使用Entry对象中的方法getKey()和getValue()获取键与值
             String key = entry.getKey();
             Integer value = entry.getValue();
             System.out.println(key+"="+value);
         }
         System.out.println("-----------------------");
         for(Map.Entry<String,Integer> entry:set){
             //3.使用Entry对象中的方法getKey()和getValue()获取键与值
             String key = entry.getKey();
             Integer value = entry.getValue();
             System.out.println(key+"="+value);
         }
     }

　　注意：Map集合不能直接使用迭代器或者foreach进行遍历。但是转成 Set 之后就可以使用了。

四、Map 实现类

　　HashMap 类

　　LinkedHashMap 类

　　TreeMap 类

　　HashTable 类

　　Properties 类

　　1、HashMap 与 Hashtable 的区别与联系

　　　　① HashMap和Hashtable都是哈希表来实现的。

　　　　② HashMap和Hashtable判断两个 key 相等的标准是：两个 key 的hashCode 值相等，并且 equals() 方法也返回 true。因此，为了成功地在哈希表中存储和获取对象，用作键的对象必须实现 hashCode 方法和 equals 方法。

　　　　③ Hashtable是线程安全的，任何非 null 对象都可以用作键或值。

　　　　④ HashMap是线程不安全的，并允许使用 null 值和 null 键。

　　2、HashMap 与 LinkedHashMap 的区别与联系

　　　　LinkedHashMap 是 HashMap 的子类。此实现与 HashMap 的不同之处在于，后者维护着一个运行于所有条目的双重链接列表。此链接列表定义了迭代顺序，该迭代顺序通常就是将键插入到映射中的顺序（插入顺序）。LinkedHashMap比HashMap要做的事多，效率低，只在需要维护顺序时再使用它。

　　3、HashMap 与 TreeMap 区别与联系

　　　　① HashMap 是无序的；

　　　　② TreeMap 会按照 key 排大小顺序，基于红黑树（Red-Black tree）的 NavigableMap 实现。该映射根据其键的自然顺序进行排序，或者根据创建映射时提供的 Comparator 进行排序，具体取决于使用的构造方法。

　　4、Properties

　　　　    Properties 类是 Hashtable 的子类，不允许key和value是null，并且它的key和value的类型都是String。Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串，通常用于存储配置属性。

　　5、所有的Map的key不能重复，如何实现不重复?

　　　　(1) HashMap、Hashtable、LinkedHashMap、Properties：依据key的hashCode和equals方法

　　　　(2) TreeMap：依据key的大小，认为大小相等的两个key就是重复的

　　　　注意：

　　　　　　（1）如果key重复了，那么后面的value会替换原来的value，即把原来的值覆盖掉。

　　　　　　（2）TreeMap要让key排大小，要么key类型本身实现了java.lang.Comparable接口，要么在创建TreeMap时，指定一个java.util.Comparator接口的实现类对象。

五、Map 的底层实现是什么？

　　对于 Map 的五个实现类，可以分为两类：

　　HashMap，LinkedHashMap，Hashtable，Properties 都是通过哈希表来实现的。

　　TreeMap 是通过红黑树来实现的。

　　HashMap 的底层实现：哈希表

　　　　JDK1.7 以及之前：数组 + 链表的结构实现哈希表

　　　　JDK1.8 以及之后：数组 + 链表/红黑树实现哈希表

　　哈希表：

　　　　在 JDK1.8 之前，哈希表底层采用数组+链表实现，即使用链表处理冲突，同一hash值的链表都存储在一个链表里。但是当位于一个桶中的元素较多，即hash值相等的元素较多时，通过key值依次查找的效率较低。

　　　　JDK1.8中（之后），哈希表存储采用数组+链表+红黑树实现，当链表长度超过阈值（8）时，将链表转换为红黑树，这样大大减少了查找时间。

　　为什么要采用这样的特殊的数据结构呢？

　　1、数组的优点：访问速度快，因为可以根据下标直接定位到某个元素

　　2、链表的优点：不需要元素是挨着存储，不需要连续空间，在添加和删除元素时不需要移动元素，只需要修改前后元素的引用关系就可以。

　　　　　　　　　　HashMap：会根据key的hashCode-->公式/算法-->[index]，因为不同的hashCode值，可能得到的[index]是相同的，那么此时就冲突了，那么只能把[index]的多个映射关系用链表连接起来

　　3、二叉树的优点：查找的速度比链表快

　　　　　　　　　　旧版的HashMap，如果key的hashCode算出了[index]相同的话（我们称为冲突）都在一个table[index]下面

　　　　　　　　　　如果严重的话，会导为什么要采用这样的特殊的数据结构呢？

　　　　　　　　　　如果[index]下面的链表很长，就会导致查询速度减慢。当链表长到一定程度时，就需要把链表变为二叉树，以提高我们查询速度。