Java基础知识之Map

冷不防 2023-09-25 18:26 63阅读 0赞

### 文章目录 ###

*   *  一、Map介绍
     *  二、Map的常用方法 \`Map应知应会\`
     *   *  2.1 调用put()方法增添数据
         *  2.2 调用remove()方法删除数据
         *  2.3 调用clear()方法清空数据
         *  2.4 调用containsKey()方法查看是否存在指定的键
         *  2.5 调用containsValue()方法查看是否存在指定的值
         *  2.6 调用isEmpty()方法判断集合是否为空
         *  2.7 调用get()方法根据键获取值
         *  2.8 调用keySet()方法获取所有键集合
     *  三、Map的基本操作代码 \`Map入门\`
     *  四、Map的遍历操作 \`Map基础\`
     *  五、案例Map集合储存学生对象并遍历 \`Map基础强化\`

## 一、Map介绍 ##

> Map是用于保存具有映射关系的数据集合，它具有双列存储的特点，即一次必须添加两个元素，即一组键值对==><Key,Value>，其中Key的值不可重复（当Key的值重复的时候，后面插入的对象会将之前插入的具有相同的Key值的对象覆盖掉），Value的值可重复。Map作为顶级接口，它最常见的实现类是HashMap和TreeMap，作为顶级接口它抽取了所有实现类的共有方法。同时Map不具有带索引的方法，因此无法使用普通for循环来遍历Map集合

> 其中<Key,Value>键值对，在Java语言中又被称之为Entry/entry，Map.Entry就相当于Student.name，若name的数据类型为String，则Student.name的数据类型为String，同理若<key,value>中key的数据类型为Integer，value的数据类型为String，则Map.Entry的数据类型为<Integer,String>。

接下来我们将结合代码来具体学习Map相关知识。

## 二、Map的常用方法 `Map应知应会` ##

> Map作为顶级接口，它最常见的实现类是HashMap和TreeMap，作为顶级接口它抽取了所有实现类的共有方法，所有实现Map接口的实现类均可使用这些方法。例如HashMap和TreeMap均可使用如下共有方法。

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>V put(K key,V value)</td> 
   <td>增添数据</td> 
  </tr> 
  <tr> 
   <td>V remove(Object Key)</td> 
   <td>根据键删除键值对元素</td> 
  </tr> 
  <tr> 
   <td>void clear()</td> 
   <td>移除所有的键值对元素</td> 
  </tr> 
  <tr> 
   <td>boolean containsKey(Object key)</td> 
   <td>判断集合是否包含指定的键</td> 
  </tr> 
  <tr> 
   <td>boolean containsValue(Object value)</td> 
   <td>判断集合是否包含指定的值</td> 
  </tr> 
  <tr> 
   <td>boolean isEmpty()</td> 
   <td>判断集合是否为空</td> 
  </tr> 
  <tr> 
   <td>V get(Object key)()</td> 
   <td>根据键获取值</td> 
  </tr> 
  <tr> 
   <td>Set keySet()</td> 
   <td>获取所有键集合</td> 
  </tr> 
 </tbody> 
</table>

### 2.1 调用put()方法增添数据 ###

具体实现类为HashMap的Map

public static void main(String[] args) {
        
            //Map为双列存储（一次必须同时存储两个元素）,<key,value>key是键，value是值，键不可以重复，值可以重复
            //创建一个Key数据类型为Integer类型和Value数据类型为String类型的Map对象，由于Map是一个接口，因此在创建对象时必须指定具体实现类（TreeMap和HashMap均可）
            Map<Integer,String> map=new HashMap<>();
            //调用put()方法增添数据
            map.put(18,"aaa");
            map.put(20,"bbb");
            map.put(19,"ccc");
            //输出数据
            System.out.println(map);
        }

运行结果：  
![在这里插入图片描述][9f27a8ba059644708da256712556d4a3.png]

--------------------

具体实现类为TreeMap的Map

public static void main(String[] args) {
        
            //Map为双列存储（一次必须同时存储两个元素）,<key,value>key是键，value是值，键不可以重复，值可以重复
            //创建一个Key数据类型为Integer类型和Value数据类型为String类型的Map对象，由于Map是一个接口，因此在创建对象时必须指定具体实现类（TreeMap和HashMap均可）
            Map<Integer,String> map=new TreeMap<>();
            //调用put()方法增添数据
            map.put(18,"aaa");
            map.put(20,"bbb");
            map.put(19,"ccc");
            //输出数据
            System.out.println(map);
        }

运行结果：  
![在这里插入图片描述][4072a52271ab4abb938ed595f40e6030.png]

--------------------

### 2.2 调用remove()方法删除数据 ###

> 接下来我们以具体实现类为HashMap的Map来举例

public static void main(String[] args) {
        
            //Map为双列存储（一次必须同时存储两个元素）,<key,value>key是键，value是值，键不可以重复，值可以重复
            //创建一个Key数据类型为Integer类型和Value数据类型为String类型的Map对象，由于Map是一个接口，因此在创建对象时必须指定具体实现类（TreeMap和HashMap均可）
            Map<Integer,String> map=new HashMap<>();
            //调用put()方法增添数据
            map.put(18,"aaa");
            map.put(20,"bbb");
            map.put(19,"ccc");
            //调用remove()方法删除数据
            map.remove(18);
            //输出数据
            System.out.println(map);
        }

运行结果：  
![在这里插入图片描述][d88c41249c344fc9994b578aba90822c.png]

--------------------

### 2.3 调用clear()方法清空数据 ###

public static void main(String[] args) {
        
            //Map为双列存储（一次必须同时存储两个元素）,<key,value>key是键，value是值，键不可以重复，值可以重复
            //创建一个Key数据类型为Integer类型和Value数据类型为String类型的Map对象，由于Map是一个接口，因此在创建对象时必须指定具体实现类（TreeMap和HashMap均可）
            Map<Integer,String> map=new HashMap<>();
            //调用put()方法增添数据
            map.put(18,"aaa");
            map.put(20,"bbb");
            map.put(19,"ccc");
            map.put(20,"ddd");
            map.put(21,"eee");
            //调用clear()方法清空数据
            map.clear();
            //输出数据
            System.out.println(map);
        }

运行结果：  
![在这里插入图片描述][9ba1392f71cd4bec862707bb83dc24ec.png]

--------------------

### 2.4 调用containsKey()方法查看是否存在指定的键 ###

public static void main(String[] args) {
        
            //Map为双列存储（一次必须同时存储两个元素）,<key,value>key是键，value是值，键不可以重复，值可以重复
            //创建一个Key数据类型为Integer类型和Value数据类型为String类型的Map对象，由于Map是一个接口，因此在创建对象时必须指定具体实现类（TreeMap和HashMap均可）
            Map<Integer,String> map=new HashMap<>();
            //调用put()方法增添数据
            map.put(18,"aaa");
            map.put(19,"bbb");
            map.put(20,"ccc");
            //调用containsKey()方法查看是否存在指定的键
            boolean b = map.containsKey(20);
            System.out.println(b);
    
            boolean b1 = map.containsKey(21);
            System.out.println(b1);
        }

运行结果：  
![在这里插入图片描述][a7514b35578741c79177fdd67165900d.png]

--------------------

### 2.5 调用containsValue()方法查看是否存在指定的值 ###

public static void main(String[] args) {
        
            //Map为双列存储（一次必须同时存储两个元素）,<key,value>key是键，value是值，键不可以重复，值可以重复
            //创建一个Key数据类型为Integer类型和Value数据类型为String类型的Map对象，由于Map是一个接口，因此在创建对象时必须指定具体实现类（TreeMap和HashMap均可）
            Map<Integer,String> map=new HashMap<>();
            //调用put()方法增添数据
            map.put(18,"aaa");
            map.put(19,"bbb");
            map.put(20,"ccc");
            //调用containsValue()方法查看是否存在指定的值
            boolean bbb = map.containsValue("bbb");
            System.out.println(bbb);
    
            boolean ddd = map.containsValue("ddd");
            System.out.println(ddd);
        }

运行结果：  
![在这里插入图片描述][e8a8c1c1d9fc4a78b5173c1b3a45ea56.png]

### 2.6 调用isEmpty()方法判断集合是否为空 ###

public static void main(String[] args) {
        
            //Map为双列存储（一次必须同时存储两个元素）,<key,value>key是键，value是值，键不可以重复，值可以重复
            //创建一个Key数据类型为Integer类型和Value数据类型为String类型的Map对象，由于Map是一个接口，因此在创建对象时必须指定具体实现类（TreeMap和HashMap均可）
            Map<Integer,String> map=new HashMap<>();
            //调用put()方法增添数据
            map.put(18,"aaa");
            map.put(19,"bbb");
            map.put(20,"ccc");
            //调用isEmpty()方法查看集合是否为空
            boolean empty = map.isEmpty();
            System.out.println(empty);
            //调用clear()方法清空数据
            map.clear();
            调用isEmpty()方法查看集合是否为空
            boolean empty1=map.isEmpty();
            System.out.println(empty1);
        }

运行结果：  
![在这里插入图片描述][62442fc4095642c49651fb87cab9aef6.png]

--------------------

### 2.7 调用get()方法根据键获取值 ###

public static void main(String[] args) {
        
            //创建一个Key的数据类型为String,Value数据类型为Integer的Map对象，并指明其实现类为HashMap
            Map<String ,Integer> map=new HashMap<>();
            //调用put()方法增添数据
            map.put("zhangsan",18);
            map.put("lisi",19);
            map.put("wangwu",20);
            map.put("zhaoliu",21);
            //调用get()方法来获取Key值对应的Value值
            //在Map集合中Key值是非常重要的，我们可以通过Key来获取与Key对应的Value，具体方法为集合调用get()方法
            Integer zhangsan = map.get("zhangsan");
            System.out.println("Key值为zhangsan的Value值："+zhangsan);
    
            Integer lisi = map.get("lisi");
            System.out.println("Key值为lisi的Value值："+lisi);
    
            Integer wangwu = map.get("wangwu");
            System.out.println("Key值为wangwu的Value值："+wangwu);
    
            Integer zhaoliu = map.get("zhaoliu");
            System.out.println("Key值为zhaoliu的Value值："+zhaoliu);
        }

运行结果：  
![在这里插入图片描述][e9b560472b234191bec3fa6c563d74c6.png]

--------------------

### 2.8 调用keySet()方法获取所有键集合 ###

运行结果：  
![在这里插入图片描述][5bc33c4f605c4519bc7b88a53a25a427.png]

--------------------

## 三、Map的基本操作代码 `Map入门` ##

Key数据类型为String类型，Value数据类型为Integer类型的Map

public static void main(String[] args) {
        
            //若要使用Map，我们需要导入import java.util.HashMap;与import java.util.Map;
            //我们使用泛型来约束Map的数据类型,Key为String数据类型,Value为Integer数据类型
            //其具体实现类为HashMap
            Map<String,Integer> map=new HashMap<>();
            //使用put()方法来添加数据
            map.put("zhangsan",18);
            map.put("lisi",19);
            map.put("wangwu",20);
            map.put("chenliu",21);
            //普通打印
            System.out.println(map);
        }

运行结果：  
![在这里插入图片描述][cb49ae2594c54a2ca716be989e51dde2.png]

--------------------

`接下来我们探讨Key的值不可重复（当Key的值重复的时候，后面插入的对象会将之前插入的具有相同的Key值的对象覆盖掉），Value的值可重复此问题`

Key数据类型为Integer类型，Value数据类型为double类型的Map

其中第四对象和第五对象的Value值相同，第三对象与第六对象的Key值相同。

运行结果：（我们发现后面插入的第六对象将之前插入的第三对象给覆盖掉了，而第四对象与第五对象的Value值重复则不会带来任何影响）  
![在这里插入图片描述][834b0222b0ae44b4815c4423c75e6cac.png]

--------------------

## 四、Map的遍历操作 `Map基础` ##

> Map的遍历分为调用keySet()方法遍历和entrySet()方法遍历

Map调用keySet()方法遍历

public static void main(String[] args) {
        
            //若要使用Map，我们需要导入import java.util.HashMap;与import java.util.Map;
            //我们使用泛型来约束Map的数据类型,Key为Integer数据类型,Value为Double数据类型
            //其具体实现类为HashMap
            Map<Integer, Double> map=new HashMap<>();
            //使用put()方法来添加数据
            map.put(18,18.99);//第一对象
            map.put(19,20.00);//第二对象
            map.put(20,59.99);//第三对象
            map.put(21,20.11);//第四对象
            map.put(22,20.11);//第五对象
            map.put(20,99.99);//第六对象
            
            //调用keySet方法遍历
                //在Map遍历中Key占据着主导地位，可以通过Key值找到对应的Value值
                //调用keySet()方法，Set<>泛型约束应与Key的数据类型一致
                //例如在本代码中，Map<Integer, Double>，Key的数据类型为Integer，因此Set<>泛型约束也应当为Integer
                //Set<Integer> set11=map.keySet();代码的意思为将Map中所有Key值存入Set集合（18，19，20，21，22）
                //那么set11即为Key值集合
                Set<Integer> set11=map.keySet();
    
                //使用forEach()语句遍历，Integer为set11的数据类型，i为set11的复用名（相当于set11）
                //那么i就成为了Key值
                for(Integer i:set11){
        
                    //在Map遍历中Key占据着主导地位，可以通过Key值找到对应的Value值
                    //接下来我们要根据Key值来查找各个Key值对应的Value值
                    //Value数据类型为Double，设置一个Double变量来存储Value
                    //map.get(i);代码意思为根据i（Key值）找到相对应的Value值
                    Double dou=map.get(i);
                    
                    //打印输出
                    System.out.println("Key的值为："+i+"    "+"Value的值为："+dou);
                }
        }

运行结果：（我们发现输出顺序与插入顺序不一致，这是因为我们使用了Set集合来遍历Map，Set集合具有存取数据不一致的问题）  
![在这里插入图片描述][ac41d501ddbd4ade9cfab504fcb40071.png]

--------------------

Map调用entrySet()方法遍历

public static void main(String[] args) {
        
            //若要使用Map，我们需要导入import java.util.HashMap;与import java.util.Map;
            //我们使用泛型来约束Map的数据类型,Key为Integer数据类型,Value为Double数据类型
            //其具体实现类为HashMap
            Map<Integer, Double> map=new HashMap<>();
            //使用put()方法来添加数据
            map.put(18,18.99);//第一对象
            map.put(19,20.00);//第二对象
            map.put(20,59.99);//第三对象
            map.put(21,20.11);//第四对象
            map.put(22,20.11);//第五对象
            map.put(20,99.99);//第六对象
            //调用entrySet方法遍历
                //调用entrySet()方法，Set<>泛型约束应与Map.Entry的数据类型一致，即<Integer, Double>
                //<Key,Value>键值对，在Java语言中又被称之为Entry/entry，Map.Entry就相当于Student.name，若name的数据类型为String，则Student.name的数据类型为String，同理若<key,value>中key的数据类型为Integer，value的数据类型为String，则Map.Entry的数据类型为<Integer,String>，在这里就是<Integer, Double>。
                //Set<Map.Entry<Integer,Double>> set11=map.entrySet();代码的意思为将Map中所有(Key,Value)值存入Set集合[(18,18.99),(19,20.00),(20,99.99),(21,20.11),(22,20.11)]
                //那么set11即为(Key,Value)值集合
                Set<Map.Entry<Integer,Double>> set11=map.entrySet();
                //使用forEach()语句遍历，Integer为set11的数据类型，i为set11的复用名（相当于set11）
                //那么i就成为了(Key,Value)值
                for(Map.Entry<Integer,Double> i:set11){
        
                    //打印输出,直接调用getKey()方法得到Key值,直接调用getValue()得到Value值
                    System.out.println("Key的值为："+i.getKey()+"    "+"Value的值为："+i.getValue());
                }
        }

运行结果：（我们发现输出顺序与插入顺序不一致，这是因为我们使用了Set集合来遍历Map，Set集合具有存取数据不一致的问题）  
![在这里插入图片描述][e2e1f15f8c764b63aa6437904be97371.png]

--------------------

## 五、案例Map集合储存学生对象并遍历 `Map基础强化` ##

> 需求：创建一个Map集合，键是学生对象（Student），值是籍贯（String）。  
> 要求：存储三个键值对元素（Entry），并遍历

Student类

public class Student {
        
        private String name;
        private int age;
    
        public Student() {
        
        }
    
        public Student(String name, int age) {
        
            this.name = name;
            this.age = age;
        }
    
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        public int getAge() {
        
            return age;
        }
    
        public void setAge(int age) {
        
            this.age = age;
        }
    
        @Override
        public String toString() {
        
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }

Map遍历输出

public static void main(String[] args) {
        
            //若要使用Map，我们需要导入import java.util.HashMap;与import java.util.Map;
            //我们使用泛型来约束Map的数据类型,Key为Student数据类型,Value为String数据类型
            //其具体实现类为HashMap
            Map<Student, String> map=new HashMap<>();
            //创建Student对象元素
            Student student1=new Student("zhangsan",18);
            Student student2=new Student("lisi",29);
            Student student3=new Student("wangwu",33);
            //使用put()方法来添加数据
            map.put(student1,"北京");
            map.put(student2,"上海");
            map.put(student3,"广州");
            //调用keySet方法遍历
            //在Map遍历中Key占据着主导地位，可以通过Key值找到对应的Value值
            //调用keySet()方法，Set<>泛型约束应与Key的数据类型一致
            //例如在本代码中，Map<Student, String>，Key的数据类型为Student，因此Set<>泛型约束也应当为Student
            //Set<Student> set11=map.keySet();代码的意思为将Map中所有Key值存入Set集合（student1，student2，student3）
            //那么set11即为Key值集合
            Set<Student> set11=map.keySet();
    
            //使用forEach()语句遍历，Student为set11的数据类型，i为set11的复用名（相当于set11）
            //那么i就成为了Key值
            for(Student i:set11){
        
                //在Map遍历中Key占据着主导地位，可以通过Key值找到对应的Value值
                //接下来我们要根据Key值来查找各个Key值对应的Value值
                //Value数据类型为String，设置一个String变量来存储Value
                //map.get(i);代码意思为根据i（Key值）找到相对应的Value值
                String str=map.get(i);
    
                //打印输出
                System.out.println("Key的值为："+i+"    "+"Value的值为："+str);
            }
    
            System.out.println("====华丽的分割线====");
    
            //调用entrySet方法遍历
            //调用entrySet()方法，Set<>泛型约束应与Map.Entry的数据类型一致，即<Student, String>
            //<Key,Value>键值对，在Java语言中又被称之为Entry/entry，Map.Entry就相当于Student.name，若name的数据类型为String，则Student.name的数据类型为String，同理若<key,value>中key的数据类型为Integer，value的数据类型为String，则Map.Entry的数据类型为<Integer,String>，在这里就是<Student, String>。
            //Set<Map.Entry<Student, String>> set22=map.entrySet();代码的意思为将Map中所有(Key,Value)值存入Set集合[(Student("zhangsan",18),"北京"),(Student("lisi",29),“上海”),(Student("wangwu",33),“广州”)]
            //那么set22即为(Key,Value)值集合
            Set<Map.Entry<Student, String>> set22=map.entrySet();
            //使用forEach()语句遍历，Integer为set11的数据类型，i为set22的复用名（相当于set22）
            //那么i就成为了(Key,Value)值
            for(Map.Entry<Student, String> i:set22){
        
                //打印输出,直接调用getKey()方法得到Key值,直接调用getValue()得到Value值
                System.out.println("Key的值为："+i.getKey()+"    "+"Value的值为："+i.getValue());
            }
        }

运行结果：（我们发现输出顺序与插入顺序不一致，这是因为我们使用了Set集合来遍历Map，Set集合具有存取数据不一致的问题）  
![在这里插入图片描述][edd1629cced444fba5fadf4fdf56987e.png]

--------------------

OK！！！Map介绍结束！！！

[9f27a8ba059644708da256712556d4a3.png]: https://img-blog.csdnimg.cn/9f27a8ba059644708da256712556d4a3.png
[4072a52271ab4abb938ed595f40e6030.png]: https://img-blog.csdnimg.cn/4072a52271ab4abb938ed595f40e6030.png
[d88c41249c344fc9994b578aba90822c.png]: https://img-blog.csdnimg.cn/d88c41249c344fc9994b578aba90822c.png
[9ba1392f71cd4bec862707bb83dc24ec.png]: https://img-blog.csdnimg.cn/9ba1392f71cd4bec862707bb83dc24ec.png
[a7514b35578741c79177fdd67165900d.png]: https://img-blog.csdnimg.cn/a7514b35578741c79177fdd67165900d.png
[e8a8c1c1d9fc4a78b5173c1b3a45ea56.png]: https://img-blog.csdnimg.cn/e8a8c1c1d9fc4a78b5173c1b3a45ea56.png
[62442fc4095642c49651fb87cab9aef6.png]: https://img-blog.csdnimg.cn/62442fc4095642c49651fb87cab9aef6.png
[e9b560472b234191bec3fa6c563d74c6.png]: https://img-blog.csdnimg.cn/e9b560472b234191bec3fa6c563d74c6.png
[5bc33c4f605c4519bc7b88a53a25a427.png]: https://img-blog.csdnimg.cn/5bc33c4f605c4519bc7b88a53a25a427.png
[cb49ae2594c54a2ca716be989e51dde2.png]: https://img-blog.csdnimg.cn/cb49ae2594c54a2ca716be989e51dde2.png
[834b0222b0ae44b4815c4423c75e6cac.png]: https://img-blog.csdnimg.cn/834b0222b0ae44b4815c4423c75e6cac.png
[ac41d501ddbd4ade9cfab504fcb40071.png]: https://img-blog.csdnimg.cn/ac41d501ddbd4ade9cfab504fcb40071.png
[e2e1f15f8c764b63aa6437904be97371.png]: https://img-blog.csdnimg.cn/e2e1f15f8c764b63aa6437904be97371.png
[edd1629cced444fba5fadf4fdf56987e.png]: https://img-blog.csdnimg.cn/edd1629cced444fba5fadf4fdf56987e.png