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:

 1 public static void main(String[] args) {
 2         //创建Map集合对象
 3         Map<String,Integer> map = new HashMap<>();
 4         map.put("赵丽颖",168);
 5         map.put("杨颖",165);
 6         map.put("林志玲",178);
 7 
 8         //1.使用Map集合中的方法keySet(),把Map集合所有的key取出来,存储到一个Set集合中
 9         Set<String> set = map.keySet();
10 
11         //2.遍历set集合,获取Map集合中的每一个key
12         //使用迭代器遍历Set集合
13         Iterator<String> it = set.iterator();
14         while (it.hasNext()){
15             String key = it.next();
16             //3.通过Map集合中的方法get(key),通过key找到value
17             Integer value = map.get(key);
18             System.out.println(key+"="+value);
19         }
20         System.out.println("-------------------");
21         //使用增强for遍历Set集合
22         for(String key : set){
23             //3.通过Map集合中的方法get(key),通过key找到value
24             Integer value = map.get(key);
25             System.out.println(key+"="+value);
26         }
27         System.out.println("-------------------");
28         //使用增强for遍历Set集合
29         for(String key : map.keySet()){
30             //3.通过Map集合中的方法get(key),通过key找到value
31             Integer value = map.get(key);
32             System.out.println(key+"="+value);
33         }
34     }

  2、通过 遍历

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

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

     Demo:

 1 @Test
 2 public void test06(){
 3     Map map = new HashMap();
 4         
 5     map.put("张三", 175);
 6     map.put("李四", 172);
 7     map.put("王五", 178);
 8     map.put("赵六", 182);
 9 
10     Collection values = map.values();
11     for (Object value : values) {
12         System.out.println(value);
13     }
14         
15 }

  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:

 1 public static void main(String[] args) {
 2         //创建Map集合对象
 3         Map<String,Integer> map = new HashMap<>();
 4         map.put("赵丽颖",168);
 5         map.put("杨颖",165);
 6         map.put("林志玲",178);
 7 
 8         //1.使用Map集合中的方法entrySet(),把Map集合中多个Entry对象取出来,存储到一个Set集合中
 9         Set<Map.Entry<String, Integer>> set = map.entrySet();
10 
11         //2.遍历Set集合,获取每一个Entry对象
12         //使用迭代器遍历Set集合
13         Iterator<Map.Entry<String, Integer>> it = set.iterator();
14         while(it.hasNext()){
15             Map.Entry<String, Integer> entry = it.next();
16             //3.使用Entry对象中的方法getKey()和getValue()获取键与值
17             String key = entry.getKey();
18             Integer value = entry.getValue();
19             System.out.println(key+"="+value);
20         }
21         System.out.println("-----------------------");
22         for(Map.Entry<String,Integer> entry:set){
23             //3.使用Entry对象中的方法getKey()和getValue()获取键与值
24             String key = entry.getKey();
25             Integer value = entry.getValue();
26             System.out.println(key+"="+value);
27         }
28     }

  注意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]下面的链表很长,就会导致查询速度减慢。当链表长到一定程度时,就需要把链表变为二叉树,以提高我们查询速度。

  

原文地址:https://www.cnblogs.com/niujifei/p/11443865.html