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

      

  • 相关阅读:
    python基础——协程
    Python基础并发编程——进程
    Python基础并发编程——操作系统
    python基础——socket
    Python基础——网络编程
    文件操作
    深浅拷贝和流程控制
    数据类型
    基础知识
    session和cookie
  • 原文地址:https://www.cnblogs.com/niujifei/p/11443865.html
Copyright © 2011-2022 走看看