黑马程序员 Map集合

最新推荐文章于 2014-06-30 01:08:43 发布

吃番茄不吃番茄皮

最新推荐文章于 2014-06-30 01:08:43 发布

阅读量522

点赞数

分类专栏： Java 文章标签： java

本文链接：https://blog.csdn.net/kubZhaiNan/article/details/35709109

版权

Java 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

---------- android培训、java培训、期待与您交流！ ----------

Map集合

概述

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

特点

1、该集合存储键值对，一对一对往里存

2、要保证键的唯一性。

常用方法

1、添加：

添加单个元素：put(k key,V value)

添加一个集合：putAll(Map<? extends K,? extends V> m)

2、删除：

获取并移除：remove(Object key)；

清空集合中元素：clear (Object key)

3、判断：

判断集合是否为空： isEmpty()；

键对应的值是否存在：containsKey(Object key)；

值对应的键是否存在：containsValue(Object obj) 返回boolean类型

4、获取：

获取单个元素：get(Object key)；

获取长度：size()；

获取Map集合中的所有值（value），返回Conllection集合。

注：a.也可以通过get()方法的返回值来判断一个键是否存在，通过返回null来判断。

b.其中put方法：如果出现添加相同的键，那么后添加的值会覆盖原有键对应的值，并且该方法返回被覆盖的值即原值。

/**
 * Map集合方法 
*/  
import java.util.*;  
class MapDemo   
{  
    public static void sop(Object obj)  
    {  
        System.out.println(obj);  
    }  
    public static void main(String[] args)   
    {  
        //创建Map集合，并添加元素  
        Map<Integer,String> map = new HashMap<Integer,String>();  
        map.put(1,"zhangsan");  
        map.put(2,"lisi");  
        map.put(3,"wangwu");  
        map.put(4,"heihei");  
        map.put(5,"xixi");  
        //获取长度  
        int n = map.size();  
        //打印元素  
        sop("原集合：" + map + "\n长度为：" + n);  
        sop("---------------------------------------");  
        //创建新集合，并添加元素  
        Map<Integer,String> m = new HashMap<Integer,String>();  
        m.put(7,"zann");  
        m.put(9,"hewi");  
        m.put(13,"wangfei");  
        m.put(14,"huxi");  
        m.put(10,"anch");  
        //用putAll将元素添加到原集合中  
        map.putAll(m);  
        sop("putAll --新集合：" + map);  
        sop("----------------------------------");  
        //删除元素  
        sop("remove:" + map.remove(01));  
        sop("新集合：" + map);  
        sop("----------------------------------");  
        /* 
        //清空集合中的元素 
        map.clear(); 
        sop("新集合：" + map); 
        //判断是否为空集合 
        boolean be = map.isEmpty(); 
        sop("isEmpty ,null? :" + be); 
        sop("----------------------------------"); 
        */  
  
        //判断元素是否存在  
        boolean bk = map.containsKey(01);  
        boolean bv = map.containsValue("wangwu");  
        sop("判断：\n01?:" + bk + "-----  wangwu?:" + bv);  
        sop("----------------------------------");  
          
        //获取元素：get  
        String s = map.get(01);  
        String s1 = map.get(02);  
        //Integer i =  map.get("lisi");  
        //Integer i2 = map.get("zhangsan");  
        sop(map.get("lisi"));  
        sop(map.get("zhangsan"));   
        sop("获取元素get：01：" + s + ",02:" + s1);  
        sop("-----------------------------------------------");  
        //获取集合中的所有元素：Value  
        Collection<String>  coll = map.values();  
        sop("value--获取集合中所有元素：" + coll);  
        sop("----------------------------------");

Map集合中的子类：

1、HashTable：

特点底层是哈希表数据结构，不可存入null键和null值。该集合是线程同步的，效率较低

2、HashMap：

特点底层是哈希表数据结构，允许使用null值和null键。该集合是线程同步的，效率较高

3、TreeMap：

特点底层是二叉树数据结构，线程不同步，可以用于给Map集合中的键值进行排序，和Set很像，

其实，Set集合的底层就是使用了Map集合。

两种获取集合元素的方法

重点说一下获取方法中的两个：keySet()和entrySet()方法

1、keySet()方法获取元素

原理：将Map集合中的所有键存入到Set集合中，因为Set集合具备迭代器，所以可以用迭代方式取出所有的键，

再根据get方法获取每一个键对应的值。简单说就是：Map集合---->Set集合 ---->迭代器取出

import java.util.*;  
public class Temp   
{  
    public static void main(String[] args)   
    {  
        //创建Map集合，并添加元素  
        Map<Integer,String> map = new HashMap<Integer,String>();  
        map.put(2,"zhangsan");  
        map.put(6,"lisi");  
        map.put(3,"wangwu");  
        map.put(4,"heihei");  
        map.put(5,"xixi");  
        //获取map集合中的所有键的Set集合  
        Set<Integer> keySet = map.keySet();  
        //有了Set集合就可以获取其迭代器，取值  
        Iterator<Integer> it = keySet.iterator();  
        while (it.hasNext())  
        {  
            Integer i = it.next();  
            String s = map.get(i);  
            System.out.println(i + " = " + s);  
        }  
    }  
}

2、entrySet()方法获取元素

原理：将Map集合中的映射关系存入到了Set集合中，而这个映射关系的数据类型是Map.Entry

在通过迭代器将映射关系存入到Map.Entry集合中，并通过其中的getKey()和getValue()放取出键值。

/*
entrySet取出方式： 
*/  
import java.util.*;  
public class Temp  
{  
    public static void main(String[] args)   
    {  
        //创建集合，存入元素  
        Map<String,String> map = new HashMap<String,String>();  
        map.put("01","lisi1");  
        map.put("02","lisi2");  
        map.put("03","lisi3");  
        map.put("04","lisi4");  
        //获取map集合中的所有键，存入到Set集合中，  
        Set<Map.Entry<String,String>> entry = map.entrySet();  
        //通过迭代器取出map中的键值关系，迭代器接收的泛型参数应和Set接收的一致  
        Iterator<Map.Entry<String,String>> it = entry.iterator();  
        while (it.hasNext())  
        {  
            //将键值关系取出存入Map.Entry这个映射关系集合接口中  
            Map.Entry<String,String>  me = it.next();  
            //使用Map.Entry中的方法获取键和值  
            String key = me.getKey();  
            String value = me.getValue();  
            System.out.println(key + " : " + value);  
        }  
    }  
}

关于Map.Entry

Map是一个接口，其实，Entry也是一个接口，它是Map的子接口中的一个内部接口，就相当于是类中有内部类一样。

为何要定义在其内部呢？

原因：a.Map集合中村的是映射关系这样的两个数据，是先有Map这个集合，才可有映射关系的存在，

而且此类关系是集合的内部事务。

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

Map集合的应用及扩展：

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

/**
 * 获取该字符串中的字母出现的次数，如："sjokafjoilnvoaxllvkasjdfns"；希望打印的结果是：a(3)c(0).....
   通过结果发现，每个字母都有对应的次数，说明字母和次数之间有映射关系。
 */
import java.util.*; 
class Temp 
{  
    public static void main(String[] args)   
    {  
        String s = "abcsjokafjoilnvoaxllvkasjdfnsde 0[fga8/-abbdc";  
        String str = LetterNum(s);  
        System.out.println(str);  
    }  
  
    public static String LetterNum(String str)  
    {  
        //将字符串转换成字符数组，因为对每个字母进行操作  
        char[] ch = str.toCharArray();  
        //定义一个Map集合，因为打印结果的字母有顺序，所以使用TreeMap集合  
        TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>();  
        int count = 0;  
        //遍历字符数组，将每一个字母作为键去查map集合，  
        for (int i=0;i<ch.length;i++)  
        {  
            //判断集合是否含有其他非字母，是则再次循环  
            if (!(ch[i]>= 'a' && ch[i] <= 'z' || ch[i] >= 'A' && ch[i] <= 'Z'))  
                continue;  
            //取出键对应的值，不为则计数器加1，存入集合，并将计数器清零，用于下一个字母  
            Integer value = tm.get(ch[i]);  
            if (value != null)  
                count = value;  
            count++;  
            tm.put(ch[i],count);  
            count = 0;  
        }  
        //创建字符串容器，存入取出的键值即按顺序排列的字符串  
        StringBuilder sb = new StringBuilder();  
        //迭代器取出相应键值，并存入字符串容器  
        Iterator<Map.Entry<Character,Integer>> it = tm.entrySet().iterator();  
        while (it.hasNext())  
        {  
            Map.Entry<Character,Integer> me = it.next();  
            Character key = me.getKey();  
            Integer value = me.getValue();  
            sb.append(key + "(" + value + ")");  
        }  
        return sb.toString();  
    }  
}