黑马程序员java笔记之一-----Map集合

简介: Map集合:该集合存储键值对。一对一对往里存,而且要保证键的唯一性             1.  添加:                put(k key,v value)                putAll(Map

Map集合:该集合存储键值对。一对一对往里存,而且要保证键的唯一性

            1.  添加:
                put(k key,v value)
                putAll(Map<? extends k,?extends v>m)  从指定映射中将所有映射关系复制到此映射中(可选操作)。

            2.  删除
                 clear()
                 remove(Object key)
            3. 判断
                 containsValue(Object value)
                 containKey(Object key)
                 isEmpty()
            4.获取
                 get(Object key)
                 size()
                 value()  从指定映射中将所有映射关系复制到此映射中(可选操作)。

                Map
                 |---Hashtable
                                 此类实现一个哈希表,该哈希表将映射到相应的值。不可以存入null值和null键。jdk1.0,效率高
                                 为了成功地在哈希表中存储和获取对象,用作键的对象必须实现hashCode方法和equals方法.

                                   从Java 2 平台 v1.2起,此类就被改进以实现Map 接口,使它成为 Java Collections Framework

                                 中的一个成员。不像新的 collection 实现,Hashtable 是同步的,底层是哈希表数据结构。

                  |---HashMap 底层表示哈希表数据结构,允许使用null值和null值,该集合是不同步的。
                  |---TreeMap :底层是二叉树结构。线程不同步。可以用于给map集合中的键进行排序。
                               和set比较:Set底层就是使用了Map集合。

[java]  view plaincopy
  1. <span style="font-size:18px;">import java.io.ObjectOutputStream.PutField;  
  2. import java.util.Collection;  
  3. import java.util.HashMap;  
  4. import java.util.Map;  
  5.   
  6. public class MapTest {  
  7.     public static void main(String[] args){  
  8.         Map<String, String> map=new HashMap<String, String>();  
  9.         //添加元素,如果出现相同的键,那么后添加的值会覆盖原有键对应值,并put方法会返回被覆盖的值。  
  10.         System.out.println("map:"+map.put("01""zhang"));  
  11.         System.out.println("map:"+map.put("01""wsufn"));  
  12.         map.put("02""li");  
  13.         map.put("03""sun");  
  14.         map.put(null"hehe");  
  15.         map.put(nullnull);//  
  16.         map.put(null,"woish");  
  17.         map.put("04"null);  
  18.         map.put("05"null);//只允许存在一个null键,可以存在一个或多个null值  
  19.         System.out.println(map.containsKey("01"));  
  20.         System.out.println("get:"+map.get("03"));  
  21.         //可以通过get方法的返回值来判断一个键是否存在  
  22.         System.out.println(map);  
  23.         Collection<String> coll=map.values();  
  24.         // Collection<V> values() 返回此映射所包含的值的 Collection 视图。  
  25.         System.out.println(coll);  
  26.     }  
  27.   
  28. }</span>  

map集合的两种取出方式:
       一、Set<k> keySet:将map中所有的键存入到Set集合。因为set具备迭代器。
         所有可以迭代方式取出所有的键,在根据get方法。获取每一个键对应的值。
     

[java]  view plaincopy
  1. <span style="font-size:18px;">  Map集合的取出原理:将map集合转成set集合。再通过迭代器取出。  
  2.        public class MapTest {  
  3.            public static void main(String[] args){  
  4.                Map<String, String> map=new HashMap<String, String>();  
  5.                map.put("02""li");  
  6.                map.put("03""sun");  
  7.               Set<String> keyset= map.keySet();  
  8.                // Collection<V> values() 返回此映射所包含的值的 Collection 视图。  
  9.              //有了Set集合,就可以获取迭代器  
  10.               Iterator<String> it=keyset.iterator();  
  11.              while (it.hasNext()) {  
  12.               String str =(String)it.next();  
  13.                String value=map.get(str);//得到key对应的值  
  14.               System.out.println("key:"+str);//得到值,而没有得到键  
  15.               }  
  16.   }  
  17. }</span>  


二、Set<Map.Entry<k,v>> entrySet: 将map集合中的映射关系取出,存入到集合中

[java]  view plaincopy
  1.      public class MapTest {  
  2.         public static void main(String[] args){  
  3.         Map<String, String> map=new HashMap<String, String>();  
  4.         map.put("02""li");  
  5.         map.put("03""sun");  
  6.         Set<Map.Entry<String, String>> entry=map.entrySet();  
  7.         Iterator<Map.Entry<String,String>> it=entry.iterator();  
  8.         while (it.hasNext()) {  
  9.         Map.Entry<String, String>  me=it.next();  
  10.         String key= me.getKey();  
  11.         String value=me.getValue();  
  12.         System.out.println("key:"+key+",value:"+value);  
  13.            }  
  14.     }  
  15. }  

注明:Map.Entry()其实Entry也是一个接口,它是Map接口中的一个内部接口。
练习:
 因为数据是以键值对形式存在的。
 所以要使用可以排序的Map集合。TreeMap。

[java]  view plaincopy
  1. <span style="font-size:18px;">import java.util.*;  
  2.   
  3. class A implements Comparator<Student>  
  4. {  
  5.     public int compare(Student s1,Student s2)  
  6.     {  
  7.         int num = s1.getName().compareTo(s2.getName());  
  8.         if(num==0)  
  9.             return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));  
  10.             return num;  
  11.     }  
  12. }  
  13. class  MapTest  
  14. {  
  15.     public static void main(String[] args)  
  16.     {  
  17.         TreeMap<Student,String> tm = new TreeMap<Student,String>(new StuNameComparator());  
  18.          map.put("02""li");  
  19.          map.put("03""sun");  
  20. //   第一种方法:keySet  
  21.              Set<Student> keySet=tm.keySet();  
  22.              Iterator<String > it=keyset.iterator();  
  23.         while(it.hasNext()){  
  24.         Student stu=it.next();  
  25.         String addr=tm.get(stu);  
  26.         System.out.println(stu+".."+addr);  
  27.             }  
  28.   
  29. //   第二种方法: entrySet:  
  30.           
  31.         Set<Map.Entry<Student,String>> entrySet = tm.entrySet();  
  32.   
  33.         Iterator<Map.Entry<Student,String>> it = entrySet.iterator();  
  34.   
  35.         while(it.hasNext())  
  36.         {  
  37.             Map.Entry<Student,String> me = it.next();  
  38.   
  39.             Student stu = me.getKey();  
  40.             String addr = me.getValue();  
  41.             System.out.println(stu+":::"+addr);  
  42.         }  
  43.     }  
  44. }</span>  

练习:
"sdfgzxcvasdfxcvdf"获取该字符串中的字母出现的次数。
希望打印结果:a(1)c(2).....
通过结果发现,每一个字母都有对应的次数。说明字母和次数之间都有映射关系。

注意,当发现有映射关系时,可以选择map集合。因为map集合中存放就是映射关系。
什么使用map集合呢?
当数据之间存在这映射关系时,就要先想map集合。

思路:
1,将字符串转换成字符数组。因为要对每一个字母进行操作。
2,定义一个map集合,因为打印结果的字母有顺序,所以使用treemap集合。
3,遍历字符数组。
    将每一个字母作为键去查map集合。
    如果返回null,将该字母和1存入到map集合中。
    如果返回不是null,说明该字母在map集合已经存在并有对应次数。
    那么就获取该次数并进行自增。,然后将该字母和自增后的次数存入到map集合中。覆盖调用原理键所对应的值。
4,将map集合中的数据变成指定的字符串形式返回。

[java]  view plaincopy
  1. <span style="font-size:18px;">class  MapTest  
  2. {  
  3.     public static void main(String[] args)   
  4.     {  
  5.         String s= charCount("wefsdfefdc,sedffe-fsd");  
  6.         System.out.println(s);  
  7.     }  
  8.     public static String charCount(String str)  
  9.     {  
  10.         char[] chs = str.toCharArray();  
  11.         TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>();  
  12.         int count = 0;  
  13.         for(int x=0; x<chs.length; x++)  
  14.         {  
  15.                      if(!(chs[x]>='a' && chs[x]<='z' || chs[x]>='A' && chs[x]<='Z'))  
  16.               continue;  
  17.                     Integer value = tm.get(chs[x]);  
  18.             if(value!=null)  
  19.             count = value;  
  20.             count++;  
  21.             tm.put(chs[x],count);//直接往集合中存储字符和数字,因为自动装箱。  
  22.   
  23.             count = 0;  
  24.             /* 
  25.             if(value==null) 
  26.             { 
  27.                 tm.put(chs[x],1); 
  28.             } 
  29.             else 
  30.             { 
  31.                 value = value + 1; 
  32.                 tm.put(chs[x],value); 
  33.             } 
  34.             */  
  35.  }  
  36.                 StringBuilder sb = new StringBuilder();  
  37.                 Set<Map.Entry<Character,Integer>> entrySet = tm.entrySet();  
  38.         Iterator<Map.Entry<Character,Integer>>  it = entrySet.iterator();  
  39.                 while(it.hasNext())  
  40.         {  
  41.             Map.Entry<Character,Integer> me = it.next();  
  42.             Character ch = me.getKey();  
  43.             Integer value = me.getValue();  
  44.             sb.append(ch+"("+value+")");  
  45.         }  
  46.         return sb.toString();  
  47.     }  
  48. }</span>  
目录
相关文章
|
3天前
|
前端开发 JavaScript Java
Java构建工具-maven的复习笔记【适用于复习】
这篇文档由「潜意识Java」创作,主要介绍Maven的相关知识。内容涵盖Maven的基本概念、作用、项目导入步骤、依赖管理(包括依赖配置、代码示例、总结)、依赖传递、依赖范围以及依赖的生命周期等七个方面。作者擅长前端开发,秉持“得之坦然,失之淡然”的座右铭。期待您的点赞、关注和收藏,这将是作者持续创作的动力! [个人主页](https://blog.csdn.net/weixin_73355603?spm=1000.2115.3001.5343)
15 3
|
23天前
|
存储 安全 Java
Java 集合框架中的老炮与新秀:HashTable 和 HashMap 谁更胜一筹?
嗨,大家好,我是技术伙伴小米。今天通过讲故事的方式,详细介绍 Java 中 HashMap 和 HashTable 的区别。从版本、线程安全、null 值支持、性能及迭代器行为等方面对比,帮助你轻松应对面试中的经典问题。HashMap 更高效灵活,适合单线程或需手动处理线程安全的场景;HashTable 较古老,线程安全但性能不佳。现代项目推荐使用 ConcurrentHashMap。关注我的公众号“软件求生”,获取更多技术干货!
39 3
|
3天前
|
存储 Java 开发者
【潜意识Java】深入详细理解分析Java中的toString()方法重写完整笔记总结,超级详细。
本文详细介绍了 Java 中 `toString()` 方法的重写技巧及其重要
28 10
【潜意识Java】深入详细理解分析Java中的toString()方法重写完整笔记总结,超级详细。
|
1月前
|
存储 缓存 安全
Java 集合江湖:底层数据结构的大揭秘!
小米是一位热爱技术分享的程序员,本文详细解析了Java面试中常见的List、Set、Map的区别。不仅介绍了它们的基本特性和实现类,还深入探讨了各自的使用场景和面试技巧,帮助读者更好地理解和应对相关问题。
49 5
|
1月前
|
安全 Java 编译器
Kotlin教程笔记(27) -Kotlin 与 Java 共存(二)
Kotlin教程笔记(27) -Kotlin 与 Java 共存(二)
|
1月前
|
Java 开发工具 Android开发
Kotlin教程笔记(26) -Kotlin 与 Java 共存(一)
Kotlin教程笔记(26) -Kotlin 与 Java 共存(一)
|
1月前
|
Java 数据库连接 编译器
Kotlin教程笔记(29) -Kotlin 兼容 Java 遇到的最大的“坑”
Kotlin教程笔记(29) -Kotlin 兼容 Java 遇到的最大的“坑”
71 0
|
17天前
|
监控 Java
java异步判断线程池所有任务是否执行完
通过上述步骤,您可以在Java中实现异步判断线程池所有任务是否执行完毕。这种方法使用了 `CompletionService`来监控任务的完成情况,并通过一个独立线程异步检查所有任务的执行状态。这种设计不仅简洁高效,还能确保在大量任务处理时程序的稳定性和可维护性。希望本文能为您的开发工作提供实用的指导和帮助。
80 17
|
28天前
|
Java
Java—多线程实现生产消费者
本文介绍了多线程实现生产消费者模式的三个版本。Version1包含四个类:`Producer`(生产者)、`Consumer`(消费者)、`Resource`(公共资源)和`TestMain`(测试类)。通过`synchronized`和`wait/notify`机制控制线程同步,但存在多个生产者或消费者时可能出现多次生产和消费的问题。 Version2将`if`改为`while`,解决了多次生产和消费的问题,但仍可能因`notify()`随机唤醒线程而导致死锁。因此,引入了`notifyAll()`来唤醒所有等待线程,但这会带来性能问题。
Java—多线程实现生产消费者