黑马程序员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(null, null);//  
  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>  
目录
相关文章
|
人工智能 Kubernetes Java
回归开源,两位 Java 和 Go 程序员分享的开源贡献指引
Higress是一个基于Istio和Envoy的云原生API网关,支持AI功能扩展。它通过Go/Rust/JS编写的Wasm插件提供可扩展架构,并包含Node和Java的console模块。Higress起源于阿里巴巴,解决了Tengine配置重载及gRPC/Dubbo负载均衡问题,现已成为阿里云API网关的基础。本文介绍Higress的基本架构、功能(如AI网关、API管理、Ingress流量网关等)、部署方式以及如何参与开源贡献。此外,还提供了有效的开源贡献指南和社区交流信息。
2923 33
|
Java 程序员 应用服务中间件
【高薪程序员必看】万字长文拆解Java并发编程!(2 2-2)
📌 核心痛点暴击:1️⃣ 面了8家都被问synchronized锁升级?一张图看懂偏向锁→重量级锁全过程!2️⃣ 线程池参数不会配?高并发场景下这些参数调优救了项目组命!3️⃣ volatile双重检测单例模式到底安不安全?99%人踩过的内存可见性大坑!💡 独家亮点抢先看:✅ 图解JVM内存模型(JMM)三大特性,看完再也不怕指令重排序✅ 手撕ReentrantLock源码,AQS队列同步器实现原理大揭秘✅ 全网最细线程状态转换图(附6种状态转换触发条件表)
386 0
|
存储 缓存 Java
【高薪程序员必看】万字长文拆解Java并发编程!(5):深入理解JMM:Java内存模型的三大特性与volatile底层原理
JMM,Java Memory Model,Java内存模型,定义了主内存,工作内存,确保Java在不同平台上的正确运行主内存Main Memory:所有线程共享的内存区域,所有的变量都存储在主存中工作内存Working Memory:每个线程拥有自己的工作内存,用于保存变量的副本.线程执行过程中先将主内存中的变量读到工作内存中,对变量进行操作之后再将变量写入主内存,jvm概念说明主内存所有线程共享的内存区域,存储原始变量(堆内存中的对象实例和静态变量)工作内存。
479 0
|
设计模式 缓存 安全
【高薪程序员必看】万字长文拆解Java并发编程!(8):设计模式-享元模式设计指南
🌟 ​大家好,我是摘星!​ 🌟今天为大家带来的是并发编程中的经典对象复用设计模式-享元模式,废话不多说让我们直接开始。
361 0
|
存储 安全 Java
【高薪程序员必看】万字长文拆解Java并发编程!(7):不可变类设计指南
🌟 ​大家好,我是摘星!​ 🌟今天为大家带来的是并发编程中Java不可变类设计指南,废话不多说让我们直接开始。
336 0
|
机器学习/深度学习 消息中间件 存储
【高薪程序员必看】万字长文拆解Java并发编程!(9-2):并发工具-线程池
🌟 ​大家好,我是摘星!​ 🌟今天为大家带来的是并发编程中的强力并发工具-线程池,废话不多说让我们直接开始。
560 0
|
安全 Java 数据库连接
让我们讲解一下 Map 集合遍历的方式
我是小假 期待与你的下一次相遇 ~
538 43
|
人工智能 Java 程序员
Java程序员在AI时代必会的技术:Spring AI
在AI时代,Java程序员需掌握Spring AI技术以提升竞争力。Spring AI是Spring框架在AI领域的延伸,支持自然语言处理、机器学习集成与自动化决策等场景。它简化开发流程,无缝集成Spring生态,并提供对多种AI服务(如OpenAI、阿里云通义千问)的支持。本文介绍Spring AI核心概念、应用场景及开发步骤,含代码示例,助你快速入门并构建智能化应用,把握AI时代的机遇。
3028 61
Java程序员必学:JVM架构完全解读
Java 虚拟机(JVM)是 Java 编程的核心,深入理解其架构对开发者意义重大。本文详细解读 JVM 架构,涵盖类加载器子系统、运行时数据区等核心组件,剖析类加载机制,包括加载阶段、双亲委派模型等内容。阐述内存管理原理,介绍垃圾回收算法与常见回收器,并结合案例讲解调优策略。还分享 JVM 性能瓶颈识别与调优方法,分析 Java 语言特性对性能的影响,给出数据结构选择、I/O 操作及并发同步处理的优化技巧,同时探讨 JVM 安全模型与错误处理机制,助力开发者提升编程能力与程序性能。
Java程序员必学:JVM架构完全解读
|
人工智能 Java 程序员
【AI程序员】通义灵码 AI 程序员全面上线JAVA使用体验
通过 AI 程序编写一个JAVA后台项目登陆页面
1173 42

热门文章

最新文章