Java基础（Map集合)

r囧r小猫 2021-09-30 02:50 548阅读 0赞

### 一、Map接口概述 ###

Map接口是双列集合，它的每个元素都包含一个键对象（key）和一个值对象（value），对象之间存在一种对应关系，称为映射。

访问元素时，只要指定了key就能找到对应的value。

将键映射到值的对象，一个映射不能包含重复的键，每个键最多指引映射到一个值。

### 二、Map常用集合概述 ###

1.  **HashMap<K,V>**：存储数据采用的哈希表结构，元素的存取顺序不能保证一致。由于要保证键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。
2.  **LinkedHashMap<K,V>**：HashMap下有个子类LinkedHashMap，存储数据采用的哈希表结构+链表结构。通过链表结构可以保证元素的存取顺序一致；通过哈希表结构可以保证的键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。
3.  **TreeMap<K,V>**：二叉树原理保证键唯一，键是可按照指定顺序排序的。

### 三、Map接口中常用的方法 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjc5ODE4_size_16_color_FFFFFF_t_70][]

示例：

import java.util.HashMap;
    import java.util.Map;
    
    public class demo_map常用方法 {
        public static void main(String[] args) {
            //Map<K,V> K：键  V：值
            Map<String,String> map=new HashMap<>();
            //存入值，返回之前的值，如果没有，返回null
            map.put("111","aaa");
            map.put("222","bbb");
            System.out.println(map);
            //获取值 根据键获取值,不存在返回null
            String value=map.get("111");
            System.out.println(value);
            //删除指定key的值
            map.remove("111");
            System.out.println(map);
        }
    }

运行结果：

![20190722162012622.png][]

### 四、Map集合的遍历 ###

两种遍历方式

示例：

import java.util.HashMap;
    import java.util.Map;
    import java.util.Set;
    
    public class demo_集合遍历 {
        public static void main(String[] args) {
            Map<String,String> map=new HashMap<>();
            map.put("1","aaa");
            map.put("2","bbb");
            map.put("3","ccc");
            map.put("4","ddd");
            map.put("5","eee");
            //第一种遍历方式
            //1.先获取所有的键
            Set<String> key=map.keySet();
            //2.遍历键的集合
            for(String k:key){
                String value=map.get(k);
                System.out.println("获取到的键和值："+k+" "+value);
            }
            System.out.println("-----------------");
            //第二种遍历方式map.entrySet()ctrl+alt+v
            //1.获取所有键值对
            Set<Map.Entry<String, String>> entries = map.entrySet();
            //2.遍历set集合，获取键值对象
            for(Map.Entry<String,String>entry:entries){
                String key1=entry.getKey();
                String value1=entry.getValue();
                System.out.println("获取到的键和值："+key1+" "+value1);
            }
        }
    }

运行结果：

![20190722162336736.png][]

### 五、HashMap存储自定义类型键值 ###

HashMap中存放自定义对象时，如果自定义对象作为key存在，这时要保证对象唯一，必须复写对象的hashCode和equals方法

示例：

import java.util.HashMap;
    
    public class HashMap_存储自定义对象 {
        public static void main(String[] args) {
            HashMap<Student,String> hashMap=new HashMap<>();
            hashMap.put(new Student("yyy",18),"111");
            hashMap.put(new Student("wtc",18),"222");
            hashMap.put(new Student("yyy",18),"333");
            System.out.println(hashMap);
        }
    }
    class Student{
        String name;
        int age;
    
        public Student(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        @Override
        public boolean equals(Object o) {
            return super.equals(o);
        }
    
        @Override
        public int hashCode() {
            return this.name.hashCode()+age;
        }
    
        @Override
        public String toString() {
            return "姓名：" + name  +
                    " 年龄：" + age;
        }
    }

运行结果：

![20190722162732982.png][]

### 六、TreeMap的使用 ###

二叉树原理保证键唯一，键是可按照指定顺序排序的。

示例：

import java.util.Comparator;
    import java.util.TreeMap;
    
    public class demo_treemap {
        public static void main(String[] args) {
            //TreeMap键是有序的
            TreeMap<String,String> treeMap=new TreeMap<>();
            treeMap.put("02","aaa");
            treeMap.put("01","aaa");
            treeMap.put("04","aaa");
            treeMap.put("03","aaa");
            System.out.println(treeMap);
            /**
             * 自定义对象作为TreeMap的key
             */
            TreeMap<Teacher,String> treeMap1=new TreeMap<>(new Comparator<Teacher>() {
                @Override
                public int compare(Teacher o1, Teacher o2) {
                    //按年龄排序
                    return o1.age-o2.age;
                }
            });
            treeMap1.put(new Teacher("yyy",19),"aaa");
            treeMap1.put(new Teacher("wtc",18),"bbb");
            treeMap1.put(new Teacher("yw",20),"ccc");
            System.out.println(treeMap1);
        }
    }
    class Teacher {
        String name;
        int age;
    
        public Teacher(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        @Override
        public String toString() {
            return "Teacher{" +
                    "姓名：" + name+
                    '}';
        }
    }

运行结果：

![2019072216322781.png][]

### 七、练习题 ###

1.TreeMap统计字符串出现次数

示例：

import java.util.TreeMap;
    import java.util.Set;
    public class demo_TreeMap统计字符串出现次数 {
        public static void main(String[] args) {
            String s="zzzszsdxxaasswwwayy";
            TreeMap<Character,Integer> treeMap=new TreeMap<>();
            for(int i=0;i<s.length();i++){
                char c=s.charAt(i);
                Integer value=treeMap.get(c);
                if(value!=null){
                    //之前存过值
                    value++;
                    treeMap.put(c,value);
                }
                else{
                    //之前没存过
                    treeMap.put(c,1);
                }
            }
            StringBuffer ss=new StringBuffer();
            Set<Character> keyset=treeMap.keySet();
            for(Character key:keyset){
                ss.append(key).append("(").append(treeMap.get(key)).append(")   ");
            }
            System.out.println(ss.toString());
        }
    }

运行结果：

![20190722163527327.png][]

2.HashMap集合嵌套HashMap集合的案例

示例：

import java.util.HashMap;
    import java.util.Set;
    import java.util.Map;
    
    public class demo_模拟存储班级信息 {
        public static void main(String[] args) {
            HashMap<String,String> hashMap1=new HashMap<>();
            hashMap1.put("001","小米");
            hashMap1.put("002","糖糖");
            hashMap1.put("002","妮妮");
            HashMap<String,String> hashMap2=new HashMap<>();
            hashMap2.put("001","天天");
            hashMap2.put("002","乐乐");
            hashMap2.put("002","可可");
            HashMap<String,HashMap<String,String>> hashMap=new HashMap<>();
            hashMap.put("2017",hashMap1);
            hashMap.put("2018",hashMap2);
            //第一种键找值
            Set<String> keyset=hashMap.keySet();
            for(String key:keyset){
                HashMap<String,String> ch=hashMap.get(key);
                Set<String> chkeyset=ch.keySet();
                System.out.println(key);
                for(String chk:chkeyset){
                    System.out.println("学号："+chk+" 姓名："+ch.get(chk));
                }
            }
            System.out.println("---------------------------");
            //第二种获取键值对
            Set<Map.Entry<String,HashMap<String,String>>> entrySet=hashMap.entrySet();
            for(Map.Entry<String,HashMap<String,String>> entry:entrySet){
                String key=entry.getKey();
                HashMap<String,String> childHashmap=entry.getValue();
                System.out.println(key);
                for(Map.Entry<String,String> chEntry:childHashmap.entrySet()){
                    String s1=chEntry.getKey();
                    String s2=chEntry.getValue();
                    System.out.println("学号："+s1+" 姓名："+s2);
                }
            }
    
        }
    }

运行结果：

![20190722163817810.png][]

3.ArrayList集合嵌套HashMap集合

示例：

import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.Set;
    import java.util.Map;
    
    public class demo_Arraylist嵌套map {
        public static void main(String[] args) {
            HashMap<String,String> hashMap1=new HashMap<>();hashMap1.put("001","小米");
            hashMap1.put("002","糖糖");
            hashMap1.put("002","妮妮");
            HashMap<String,String> hashMap2=new HashMap<>();
            hashMap2.put("001","天天");
            hashMap2.put("002","乐乐");
            hashMap2.put("002","可可");
            ArrayList<HashMap<String,String>> list=new ArrayList<>();
            list.add(hashMap1);
            list.add(hashMap2);
            //第一种方式
            for(int i=0;i<list.size();i++){
                HashMap<String,String> hashMap=list.get(i);
                Set<Map.Entry<String,String>> entrySet=hashMap.entrySet();
                for(Map.Entry<String,String> entry:entrySet){
                    System.out.println("学号："+entry.getKey()+"姓名："+entry.getValue());
                }
            }
            System.out.println("-----------------");
            //第二种方式
            for(HashMap<String,String> hashMap:list){
                Set<Map.Entry<String,String>> entrySet=hashMap.entrySet();
                for(Map.Entry<String,String> entry:entrySet){
                    System.out.println("学号："+entry.getKey()+" 姓名:"+entry.getValue());
                }
            }
        }
    }

运行结果：

![2019072216413248.png][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjc5ODE4_size_16_color_FFFFFF_t_70]: /images/20210920/de5a673c4fc24c33adf2a45acaa7ca94.png
[20190722162012622.png]: /images/20210920/2695f8c1fe0045b7bb14b657988d8b38.png
[20190722162336736.png]: /images/20210920/d4f40570b68d4ad9bf4e3b77b467f99f.png
[20190722162732982.png]: /images/20210920/7b7a3af937ff4bdeb0c78607669b2002.png
[2019072216322781.png]: /images/20210920/1af45348d0324e82a58318777d88854f.png
[20190722163527327.png]: /images/20210920/32c9c627b50e4cbb85d21fabe1dc8a82.png
[20190722163817810.png]: /images/20210920/c6e7a9e6cf034ea8a61f8aecdc6f7c39.png
[2019072216413248.png]: /images/20210920/a2c38cc624004350b297024b1b3ce058.png