• 黑马程序员——Java基础---集合(二)------Map集合


    ------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流! ------- 

                             Map集合

    一、概述

    1、简述:

            Map<K,V>集合是一个接口,和List集合及Set集合不同的是,它是双列集合,并且可以给对象加上名字,即键(Key)

    2、特点:

            1)该集合存储键值对,一对一对往里存

            2)要保证键的唯一性。

     

    二、Map集合的子类

            Map

                |--Hashtable:底层是哈希表数据结构,不可以存入null键null值。该集合是线程同步的。JDK1.0,效率低。

                |--HashMap:底层是哈希表数据结构。允许使用null键null值,该集合是不同步的。JDK1.2,效率高。

                |--TreeMap:底层是二叉树数据结构。线程不同步。可以用于给Map集合中的键进行排序。

            Map和Set很像。其实Set底层就是使用了Map集合。

     

    三、Map集合的常用方法

    1、添加

            Vput(K key,V value);//添加元素,如果出现添加时,相同的键,那么后添加的值会覆盖原有键对应值,并put方法会返回被覆盖的值。

            voidputAll(Map <? extends K,? extends V> m);//添加一个集合

    2、删除

            clear();//清空

            Vremove(Object key);//删除指定键值对

    3、判断

            containsKey(Objectkey);//判断键是否存在

            containsValue(Objectvalue)//判断值是否存在

            isEmpty();//判断是否为空

    4、获取

            Vget(Object key);//通过键获取对应的值

            size();//获取集合的长度

            Collection<V>value();//获取Map集合中所以得值,返回一个Collection集合

    还有两个取出方法,接下来会逐个讲解:

            Set<Map.Entry<K,V>>entrySet();

            Set<K>  keySet();

    注:HashMap集合可以通过get()方法的返回值来判断一个键是否存在,通过返回null来判断。

     建立学生类:

    四、Map集合的两种取出方式

            

     1 /*
     2 map集合的两种取出方式:
     3 1    Set<k> keySet: 将map中所有的键存入到Set集合。因为set具备迭代器。
     4         所有可以迭代方式取出所有的键,在根据get方法。获取每一个键对应的值
     5 
     6         Map集合的取出原理: 将map集合转成set集合
     7 
     8 2    Set<Map.Entry<k,v>> entrySet:将map集合中的映射关系存入到了set集合中,
     9                             而这个关系的数据类型就是:Map.Entry
    10 
    11                             Entry其实就是Map中的一个static内部接口
    12                             为什么要定义在内部类呢?
    13                             因为只有有了Map集合,有了键值对,才会有键值的映射关系
    14                             关系属于Map集合中的一个内部事物
    15                             而且该事物在直接访问Map集合中的元素
    16 */
    17 import java.util.*;
    18 class MapDemo2
    19 {
    20     public static void main(String[] args)
    21     {
    22         Map<String,String>map=new HashMap<String,String>();
    23         map.put("02","zhangsan2");
    24         map.put("03","zhangsan3");
    25         map.put("01","zhangsan1");
    26         map.put("04","zhangsan4");
    27 
    28         /*将Map集合中的映射关系取出。存入到Set集合中
    29         Set<Map.Entry<String,String>> entrySet=map.entrySet();
    30         Iterator<Map.Entry<String,String>>it=entrySet.iterator();
    31         while(it.hasNext())
    32         {
    33             Map.Entry<String,String> me=it.next();
    34             String key=me.getKey();//通过映射关系取出键
    35             String value=me.getValue();//通过映射关系取出值
    36             System.out.println(key+":"+value);
    37         }
    38         */
    39         //先获取map集合的所有键的Set集合,keySet();
    40         Set<String> qq = map.keySet();
    41 
    42         //有了Set集合。就可以获取其迭代器。
    43         Iterator<String> it = qq.iterator();
    44 
    45         while(it.hasNext())
    46         {
    47             String key = it.next();
    48             //有了键可以通过map集合的get方法获取其对应的值。
    49             String value  = map.get(key);
    50             System.out.println("key:"+key+",value:"+value);
    51         }
    52     }
    53 }

    关于Map.Entry:

            Map是一个接口,其实,Entry也是一个接口,它是Map的子接口中的一个内部接口,就相当于是类中有内部类一样。为何要定义在其内部呢?

            原因:a、Map集合中村的是映射关系这样的两个数据,是先有Map这个集合,才可有映射关系的存在,而且此类关系是集合的内部事务。

                         b、并且这个映射关系可以直接访问Map集合中的内部成员,所以定义在内部。

    五、Map集合的应用及扩展

    1、何时使用Map集合:当量数据之间存在着映射关系的时候,就应该想到使用Map集合。

    2、示例:

            获取该字符串中的字母出现的次数,如:"sjokafjoilnvoaxllvkasjdfns";希望打印的结果是:a(3)c(0).....

            通过结果发现,每个字母都有对应的次数,说明字母和次数之间有映射关系。代码如下:

    示例2:

     1 /*练习
     2 "sdfgzxcvasdfxcvdf"获取该字符串中的字母出现的次数。
     3 希望打印结果:a(1)c(2).....
     4 
     5 通过结果发现,每一个字母都有对应的次数。
     6 说明字母和次数之间都有映射关系。
     7 
     8 注意了,当发现有映射关系时,可以选择map集合。
     9 因为map集合中存放就是映射关系。
    10 
    11 
    12 什么时候使用map集合呢?
    13 当数据之间存在着映射关系时,就要先想map集合
    14 
    15 思路:
    16 1    将字符 串转换成字符数组。因为要对每一个字母进行操作
    17 
    18 2    定义一个map集合,因为打印结果的字母有顺序,所以使用treemap集合。
    19 3    遍历字符数组
    20             将每一个字母作为键去查map集合
    21             如果返回null,将该字母和1存入到map集合中
    22             如果返回不是null,说明该字母在map集合已经存在并有对应的次数
    23             那么就获取该次数并进行自增,然后将该字母和自增后的次数存入
    24 4    将Map集合中的数据变成指定的字符串形式返回。
    25 */
    26 import java.util.*;
    27 class MapTest3
    28 {
    29     public static void main(String[] args)
    30     {String s="ak+abAf1c,dCkaAbc-defa";
    31     System.out.println(s);
    32     String s1= charCount("ak+abAf1c,dCkaAbc-defa");
    33     System.out.println(s1);
    34     }
    35 
    36     public  static String charCount(String s)
    37     {
    38         char[] chs=s.toCharArray();
    39         TreeMap<Character,Integer>  tm=new TreeMap<Character,Integer>();//创建容器限定存入类型
    40         
    41         int count =0;
    42         for(int x=0;x<chs.length;x++)
    43         {
    44             if(!(('a'<=chs[x]&&chs[x]<='z')||('A'<=chs[x]&&chs[x]<='Z')))//去除非字母元素
    45                 continue;
    46             Integer value=tm.get(chs[x]);//通过键获取值
    47             if(value!=null)//如果该值不为空
    48                 count=value;
    49             count++;
    50             tm.put(chs[x],count);//直接往集合中存储字符和数字,为什么可以?因为自动装箱
    51 
    52             count=0;
    53 
    54         }
    55         StringBuilder sb=new StringBuilder();//建立字符串缓冲区
    56         Set<Map.Entry<Character,Integer>> entrySet=tm.entrySet();//建立映射关系的集合
    57         Iterator<Map.Entry<Character,Integer>>it=entrySet.iterator();//调用集合中的迭代器
    58 
    59         while(it.hasNext())
    60         {
    61             Map.Entry<Character,Integer>me=it.next();//将映射关系存入 me  中
    62             Character ch=me.getKey();
    63             Integer value=me.getValue();
    64             sb.append(ch+"("+value+")");//字符串容器添加元素
    65         }
    66         return sb.toString();//转成字符串
    67     }
    68 }

    六、Map扩展知识

            在很多项目中,应用比较多的是一对多的映射关系,这就可以通过嵌套的形式将多个映射定义到一个大的集合中,并将大的集合分级处理,形成一个体系。

     1 /*
     2 map扩展知识
     3 map集合被使用是因为具备映射关系
     4 
     5 "yureban"   Student("01" "zhangsan");
     6 
     7 "yureban" Student("02" "lisi");
     8 
     9 "jiuyeban" "01" "wangwu";
    10 "jiuyeban" "02" "zhaoliu";
    11 一个学校有多个教师,每一个教师都有名称。
    12 */
    13 import java.util.*;
    14 class Student//构建学生对象
    15 {
    16     private String id;
    17     private String name;
    18     Student(String id,String name)
    19     {
    20         this.id=id;
    21         this.name=name;
    22     }
    23     public String toString()
    24     {
    25         return id+"::"+name;
    26     }
    27 }
    28 class lianxi2
    29 {
    30     public static void main(String[] args) 
    31     {
    32     
    33         HashMap<String,String>  yure = new HashMap<String,String>();//建立HashMap集合
    34             yure.put("01","zhagnsan");//添加元素
    35             yure.put("02","lisi");
    36         HashMap<String,String> jiuye = new HashMap<String,String>();
    37             jiuye.put("01","zhaoliu");
    38             jiuye.put("02","wangwu");
    39 
    40         HashMap<String,HashMap<String,String>> czbk = new HashMap<String,HashMap<String,String>>();
    41             czbk.put("yureban",yure);//集合中存在集合
    42             czbk.put("jiuyeban",jiuye);
    43 
    44         //遍历czbk集合。获取所有的教室。
    45         Iterator<String> it = czbk.keySet().iterator();
    46 
    47         while(it.hasNext())
    48         {
    49             String roomName = it.next();
    50             HashMap<String,String> room = czbk.get(roomName);
    51         //    
    52             System.out.println(roomName);//输出教室名称
    53             getStudentInfo(room);//遍历教室,获取学生信息
    54         }
    55 
    56         
    57     //getStudentInfo(jiuye);
    58     //getStudentInfo(yure);
    59 
    60         
    61     }
    62     public static void getStudentInfo(HashMap<String,String> roomMap)
    63     {
    64         Iterator<String> it = roomMap.keySet().iterator();//调用roomMap集合中的迭代器
    65 
    66         while(it.hasNext())//遍历  教室中的学生名称
    67         {
    68             String id = it.next();
    69             String name = roomMap.get(id);
    70             System.out.println(id+":"+name);
    71         }
    72     }
    73 }

    自我总结:

      Map集合的特殊之处,便是键值对的成对出现,不仅可以通过键获取值,更可以通过二者的关系获取键和值。提供了一对多的环境。而通过循环的嵌套,可以形成金字塔状的网,这也对应着现实中很多存在,例如一个公司有很多部门,而一个部门对应很多员工一般。Map集合在生活中有很大的应用,例如工人拿计件工资时,便更是如此,每个人都有对应的件数,而且不能乱。Map集合便可以很好的体现这一点。

  • 相关阅读:
    设计模式4---策略模式
    设计模式3---抽象工厂模式
    209. Minimum Size Subarray Sum(双指针)
    174. Dungeon Game(动态规划)
    二分查找
    74. Search a 2D Matrix(二分查找,剑指offer 1)
    81. Search in Rotated Sorted Array II
    33. Search in Rotated Sorted Array(二分查找)
    34. Search for a Range (二分查找)
    35. Search Insert Position(二分查找)
  • 原文地址:https://www.cnblogs.com/ktlshy/p/4716759.html
走看看 - 开发者的网上家园