Java中Map常用方法总结以及遍历方式的汇总

最新推荐文章于 2023-02-21 17:07:28 发布

软件测试开发架构师

最新推荐文章于 2023-02-21 17:07:28 发布

阅读量433

点赞数

分类专栏： Java面试文章标签： Java map map循环遍历

Java面试专栏收录该内容

65 篇文章 2 订阅

订阅专栏

原文地址https://www.cnblogs.com/lwlxqlccc/p/6143887.html

原文地址https://www.cnblogs.com/jpwz/p/5680494.html

原文地址https://blog.csdn.net/u013630349/article/details/71693521

Java中Map常用操作说明
　　void clear()
　　从此映射中移除所有映射关系（可选操作）。

　　boolean containsKey(Object key)
　　如果此映射包含指定键的映射关系，则返回 true。

　　boolean containsValue(Object value)
　　如果此映射将一个或多个键映射到指定值，则返回 true。

　　Set<Map.Entry<K,V>> entrySet()
　　返回此映射中包含的映射关系的 Set 视图。

　　boolean equals(Object o)
　　比较指定的对象与此映射是否相等。

　　V get(Object key)
　　返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。

　　int hashCode()
　　返回此映射的哈希码值。

　　boolean isEmpty()
　　如果此映射未包含键-值映射关系，则返回 true。

　　Set<K> keySet()
　　返回此映射中包含的键的 Set 视图。

　　V put(K key, V value)
　　将指定的值与此映射中的指定键关联（可选操作）。

　　void putAll(Map<? extends K,? extends V> m)
　　从指定映射中将所有映射关系复制到此映射中（可选操作）。

　　V remove(Object key)
　　如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。

　　int size()
　　返回此映射中的键-值映射关系数。

　　Collection<V> values()
　　返回此映射中包含的值的 Collection 视图。

Map的一般用法
1.声明一个Map:
   Map map = new HashMap();

2.向map中放值，注意： map是key-value的形式存放的，如：
       map.put("sa","dd");

3.从map中取值:
    String str = map.get("sa").toString,
    结果是： str = "dd'

4.遍历一个map,从中取得key和value:
    Map m= new HashMap();
    for(Object obj : map.keySet()){
          Object value = map.get(obj );
    }

==================================================================

Java中Map常用方法总结以及遍历方式的汇总

一、整理：

看到array，就要想到角标。

看到link，就要想到first，last。

看到hash，就要想到hashCode,equals.

看到 tree，就要想到两个接口。Comparable，Comparator。

二、Map与Collection在集合框架中属并列存在

1.Map存储的是键值对

2.Map存储元素使用put方法，Collection使用add方法

3.Map集合没有直接取出元素的方法，而是先转成Set集合，在通过迭代获取元素

4.Map集合中键要保证唯一性

也就是Collection是单列集合, Map 是双列集合。

总结:

Map一次存一对元素, Collection 一次存一个。Map 的键不能重复，保证唯一。

Map 一次存入一对元素,是以键值对的形式存在.键与值存在映射关系.一定要保证键的唯一性.

三、Map中常见方法：

1、添加：

1、V put(K key, V value) （可以相同的key值，但是添加的value值会覆

盖前面的，返回值是前一个，如果没有就返回null）

2、putAll(Map<? extends K,? extends V> m) 从指定映射中将所有映射关

系复制到此映射中（可选操作）。

2、删除

1、remove() 删除关联对象，指定key对象

2、clear() 清空集合对象

3、获取

1：value get(key); 可以用于判断键是否存在的情况。当指定的键不存在的时候，返回的是null。

3、判断：

1、boolean isEmpty() 长度为0返回true否则false

2、boolean containsKey(Object key) 判断集合中是否包含指定的key

3、boolean containsValue(Object value) 判断集合中是否包含指定的value

4、长度：Int size（）

四、遍历Map的方式：

1、将map 集合中所有的键取出存入set集合。

Set<K> keySet() 返回所有的key对象的Set集合，再通过get方法获取键对应的值。

2、 values() ，获取所有的值.

Collection<V> values()不能获取到key对象

3、 Map.Entry对象推荐使用重点

Set<Map.Entry<k,v>> entrySet() 将map 集合中的键值映射关系打包成一个对象。

Map.Entry对象通过Map.Entry 对象的getKey，getValue获取其键和值。

第一种方式:使用keySet

将Map转成Set集合（keySet()），通过Set的迭代器取出Set集合中的每一个元素（Iterator）就是Map集合中的所有的键，再通过get方法获取键对应的值。

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class Demo1 {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<Integer, String>();
        map.put(1, "aaaa");
        map.put(2, "bbbb");
        map.put(3, "cccc");
        System.out.println(map);

        //
        // 获取方法：
        // 第一种方式: 使用keySet
        // 需要分别获取key和value，没有面向对象的思想
        // Set<K> keySet() 返回所有的key对象的Set集合

        Set<Integer> ks = map.keySet();
        Iterator<Integer> it = ks.iterator();
        while (it.hasNext()) {
            Integer key = it.next();
            String value = map.get(key);
            System.out.println("key=" + key + " value=" + value);
        }
    }
}

第二种方式: 通过values 获取所有值,不能获取到key对象

 1 public static void main(String[] args) {
 2         Map<Integer, String> map = new HashMap<Integer, String>();
 3         map.put(1, "aaaa");
 4         map.put(2, "bbbb");
 5         map.put(3, "cccc");
 6         System.out.println(map);
 7 // 第二种方式：
 8         // 通过values 获取所有值,不能获取到key对象
 9         // Collection<V> values()
10 
11         Collection<String> vs = map.values();
12         Iterator<String> it = vs.iterator();
13         while (it.hasNext()) {
14             String value = it.next();
15             System.out.println(" value=" + value);
16         }
17 }

第三种方式: Map.Entry

public static interface Map.Entry<K,V> 通过Map中的entrySet()方法获取存放Map.Entry<K,V>对象的Set集合。

Set<Map.Entry<K,V>> entrySet() 面向对象的思想将map集合中的键和值映射关系打包为一个对象，就是Map.Entry，将该对象存入Set集合，Map.Entry是一个对象，那么该对象具备的getKey，getValue获得键和值。

 1 public static void main(String[] args) {
 2         Map<Integer, String> map = new HashMap<Integer, String>();
 3         map.put(1, "aaaa");
 4         map.put(2, "bbbb");
 5         map.put(3, "cccc");
 6         System.out.println(map);
 7         // 第三种方式： Map.Entry对象 推荐使用 重点
 8         // Set<Map.Entry<K,V>> entrySet()
 9         
10 
11         // 返回的Map.Entry对象的Set集合 Map.Entry包含了key和value对象
12         Set<Map.Entry<Integer, String>> es = map.entrySet();
13 
14         Iterator<Map.Entry<Integer, String>> it = es.iterator();
15 
16         while (it.hasNext()) {
17             
18             // 返回的是封装了key和value对象的Map.Entry对象
19             Map.Entry<Integer, String> en = it.next();
20 
21             // 获取Map.Entry对象中封装的key和value对象
22             Integer key = en.getKey();
23             String value = en.getValue();
24 
25             System.out.println("key=" + key + " value=" + value);
26         }
27     }

==============================================================

Java集合中Map接口的使用方法

Map接口

Map提供了一种映射关系，其中的元素是以键值对（key-value）的形式存储的，能够实现根据key快速查找value；
Map中的键值对以Entry类型的对象实例形式存在；
建（key值）不可重复，value值可以重复，一个value值可以和很多key值形成对应关系，每个建最多只能映射到一个值。
Map支持泛型，形式如：Map<K,V>
Map中使用put(K key,V value)方法添加

HashMap类

HashMap是Map的一个重要实现类，也是最常用的，基于哈希表实现
HashMap中的Entry对象是无序排列的
Key值和value值都可以为null，但是一个HashMap只能有一个key值为null的映射（key值不可重复）

下面我们以添加学生对象的实例演示Map的用法。

首先，创建一个学生类

 1 import java.util.HashSet;
 2 import java.util.Set;
 3 
 4 /**
 5  * 学生类
 6  * @author lenovo
 7  *
 8  */
 9 public class Student {
10 
11     public String id;
12     
13     public String name;
14     
15     public Set<KeCheng> kecheng;
16     
17     public Student(String id,String name){
18         this.id = id;
19         this.name = name;
20         this.kecheng = new HashSet<KeCheng>();
21     }
22     
23 }

然后再创建一个MapTest的测试类，演示Map的使用方法，并且创建一个演示put()方法和keySet()方法的成员方法

 1 import java.util.HashMap;
 2 import java.util.Map;
 3 import java.util.Scanner;
 4 import java.util.Set;
 5 
 6 public class MapTest {
 7 
 8     //创建一个Map属性用来承装学生对象
 9     public Map<String,Student> student;
10     
11     /*
12      * 在构造器中初始化学生属性
13      */
14     public MapTest(){
15         this.student = new HashMap<String,Student>();
16     }
17     
18     /*
19      * 添加方法：输入学生ID，判断是否被占用，
20      * 如果未被占用，则输入姓名，创建新学生对象，添加到student中
21      */
22     public void testPut(){
23         //创建一个Scanner对象，输入学生ID
24         Scanner sc = new Scanner(System.in);
25         int i = 0;
26         while(i<3){
27             System.out.println("请输入学生ID：");
28             String stuID = sc.next();
29             Student stu = student.get(stuID);
30             if(stu == null){
31                 System.out.println("请输入学生姓名：");
32                 String stuName = sc.next();
33                 Student newStudent = new Student(stuID,stuName);
34                 student.put(stuID, newStudent);
35                 System.out.println("成功添加学生："+student.get(stuID).name);
36                 i++;
37             }else{
38                 System.out.println("该学生ID已被占用！");
39                 continue;
40             }
41             
42         }
43     }
44     
45     /*
46      * 测试Map的keySet方法
47      */
48     public void testKeySet(){
49         //通过keySet方法，返回Map中所有“键”的Set集合
50         Set<String> keySet = student.keySet();
51         //取得student的容量
52         System.out.println("总共有"+student.size()+"个学生；");
53         //遍历keySet，取得每一个键，再调用get方法取得每个键对应的value
54         for (String stuID : keySet) {
55             Student stu = student.get(stuID);
56             if(stu != null){
57                 System.out.println("学生："+stu.name);
58             }
59         }
60     }
61     
62     public static void main(String[] args) {
63 
64         MapTest mt = new MapTest();
65         mt.testPut();
66         mt.testKeySet();
67     }
68 
69 }

运行main方法后的结果如下：

请输入学生ID：
1
请输入学生姓名：
Tom
成功添加学生：Tom
请输入学生ID：
2
请输入学生姓名：
Jack
成功添加学生：Jack
请输入学生ID：
3
请输入学生姓名：
Lily
成功添加学生：Lily
总共有3个学生；
学生：Tom
学生：Jack
学生：Lily

使用Map中的remove()方法删除Map中的映射

 1 /*
 2      * 删除Map中的映射
 3      */
 4     public void testRemove(){
 5         Scanner sc = new Scanner(System.in);
 6         while(true){
 7             System.out.println("请输入要删除的学生ID：");
 8             String stuID = sc.next();
 9             //判断输入的ID是否存在对应的学生对象
10             Student stu = student.get(stuID);
11             if(stu == null){
12                 System.out.println("输入的学生ID不存在！");
13                 continue;
14             }
15             student.remove(stuID);
16             System.out.println("成功删除学生"+stu.name);
17             break;
18         }
19         testEntrySet();
20     }

使用entrySet()方法遍历Map

 1     /*
 2      * 通过entrySet来遍历Map
 3      */
 4     public void testEntrySet(){
 5         //通过entrySet返回Map中所有的键值对
 6         Set<Entry<String,Student>> entrySet = student.entrySet();
 7         for(Entry<String,Student> entry:entrySet){
 8             System.out.println("取得键："+entry.getKey());
 9             System.out.println("对应的值为："+entry.getValue().name);
10         }
11     }

使用put()方法来修改Map中已存在的映射

 1 /*
 2      * 使用put方法修改Map中已有的映射
 3      */
 4     public void testModify(){
 5         System.out.println("请输入要修改的学生ID：");
 6         Scanner sc = new Scanner(System.in);
 7         while(true){
 8             String id = sc.next();
 9             Student stu = student.get(id);
10             if(stu == null){
11                 System.out.println("ID不存在！");
12                 continue;
13             }
14             System.out.println("当前学生是："+stu.name);
15             System.out.println("请输入新的学生：");
16             String name = sc.next();
17             Student newStu = new Student(id,name);
18             student.put(id, newStu);
19             System.out.println("修改成功！");
20             break;
21         }
22     }

使用Map中的containsKey()和containsValue()方法来判断Map中是否存在键或值

 1 /*
 2      * 测试Map中是否存在某个key值或value值
 3      */
 4     public void testContainsKey(){
 5         System.out.println("请输入学生ID：");
 6         Scanner sc = new Scanner(System.in);
 7         String stuID = sc.next();
 8         //用containsKey()方法来判断是否存在某个key值
 9         System.out.println("输入的ID为："+stuID+",在学生列表中是否存在："+student.containsKey(stuID));
10         if(student.containsKey(stuID)){
11             System.out.println("学生的姓名为："+student.get(stuID).name);
12         }
13         
14         System.out.println("请输入学生姓名：");
15         String name = sc.next();
16         //用containsValue()方法来判断是否存在某个value值
17         if(student.containsValue(new Student(null,name))){
18             System.out.println("存在学生"+name);
19         }else{
20             System.out.println("学生不存在");
21         }
22     }

使用containsKey()和containsValue()方法判断是，先在学生类里重写equals()和hashCode()方法，如果只判断值的话，equals方法里只重写和值相关的内容。

软件测试开发架构师

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Java中Map常用方法总结以及遍历方式的汇总

原文地址https://www.cnblogs.com/lwlxqlccc/p/6143887.html原文地址https://www.cnblogs.com/jpwz/p/5680494.html原文地址https://blog.csdn.net/u013630349/article/details/71693521Java中Map常用操作说明　　void clear()
复制链接

扫一扫

专栏目录