Java Map系列集合

Myth丶恋晨 2024-03-27 17:33 38阅读 0赞

### 双列集合（顶层接口Map） ###

#### 双列集合特点 ####

1. 一次需要存一对数据，分别为键和值
    2. 键不能重复，值可以重复
    3. 键和值是一一对应的，每一个键只能找到自己对应的值
    4. 键+值，这个整体我们成为“键值对”或者“键值对对象”，在Java中叫做“Entry对象”

### Map的常见API ###

*  Map是双列集合的顶层接口，他的功能是全部双列集合都可以继承使用的  
    ![在这里插入图片描述][05a05fad25e34cd489be8056c531e6ab.png]
 *  **put 方法细节**：添加/覆盖
    
     *  在添加数据的时候，如果键不存在，那么直接把键值对对象添加到map集合中，方法返回null
     *  在添加数据的时候，如果键是存在的，那么会把原有的键值对对象覆盖，会把被覆盖的值返回

package com.map;
    
    import java.util.HashMap;
    import java.util.Map;
    
    public class MapDemo01 {
        
        public static void main (String[] args) {
        
    
    
            //1. 创建map对象
            Map<String,String> m = new HashMap<> ();
    
            //2. 添加元素
            /*
                put 方法细节：添加/覆盖
                    在添加数据的时候，如果键不存在，那么直接把键值对对象添加到map集合中，方法返回null
                    在添加数据的时候，如果键是存在的，那么会把原有的键值对对象覆盖，会把被覆盖的值返回
             */
            m.put ("郭靖","黄蓉");
            m.put ("韦小宝","沐剑屏");
            m.put ("尹志平","小龙女");
            /*String value2 = m.put ("尹志平","双儿");
            System.out.println (value2);*/
    
            /*//删除
            String result = m.remove ("郭靖");
            System.out.println (result);*/
    
            /*//清空
            m.clear ();*/
    
            /*//判断是否包含
            boolean keyResult = m.containsKey ("郭靖");
            System.out.println (keyResult);//true
    
            boolean valueResult = m.containsValue ("小龙女");
            System.out.println (valueResult);//true*/
    
            /*//判断集合是否为空
            boolean result = m.isEmpty ();
            System.out.println (result);*/
    
            //集合的长度
            int size = m.size ();
            System.out.println (size);
    
    
            //3. 打印集合
            System.out.println (m);
    
        }
    }

### Map集合的遍历方式 ###

#### 键找值 ####

package com.map;
    
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Map;
    import java.util.Set;
    import java.util.function.Consumer;
    
    public class MapDemo02 {
        
        public static void main (String[] args) {
        
    
            //1. 创建map对象
            Map<String,String> map = new HashMap<> ();
    
            //2. 添加元素
            map.put ("郭靖","穆念慈");
            map.put ("欧阳克","黄蓉");
            map.put ("尹志平","小龙女");
    
            //3. 通过键找值
    
            //3.1 获取所有的键，把这些键放到一个单列集合当中
            Set<String> keys = map.keySet ();
            //3.2 遍历单列集合，得到每一个键
            for (String key : keys) {
        
               // System.out.println (key);
                //3.3 利用map集合中的键，获取相应的值 get
                String value = map.get (key);
                System.out.println (key+" - " + value);
    
            }
    
            Iterator<String>  it = map.keySet ().iterator ();
            while (it.hasNext ()){
        
                String s = it.next ();
                String value2 = map.get (s);
                System.out.println (s + " - " + value2);
            }
            
            map.keySet ().forEach (new Consumer<String> () {
        
                @Override
                public void accept (String s) {
        
                    String value3 = map.get (s);
                    System.out.println (s + " - "+ value3);
                }
            });
    
            map.keySet ().forEach ((str)->{
        
                System.out.println (str + " - " + map.get (str));
            });
        }
    }

#### 键值对 ####

package com.map;
    
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Map;
    import java.util.Set;
    import java.util.function.Consumer;
    
    public class MapDemo03 {
        
        public static void main (String[] args) {
        
    
    
            //1. 创建对象
            Map<String,String> map = new HashMap<> ();
    
            //2. 添加元素
            /*
                键：任务外号
                值：任务名字
             */
            map.put ("狼狗","成吉思汗");
            map.put ("奶妈","蔡文姬");
            map.put ("电光耗子","百里玄策");
    
            //3.1 通过entrySet方法，获得所有的键值对对象，返回一个set集合
            Set<Map.Entry<String,String>> entries = map.entrySet ();
            //3.2 遍历entries这个集合，得到里面的每一个键值对对象
            for (Map.Entry<String, String> entry : entries) {
        
                //3.3 利用entry调用get方法，获取键和值
                String key = entry.getKey ();
                String value = entry.getValue ();
                System.out.println (key + " - " + value);
            }
    
            entries.forEach (new Consumer<Map.Entry<String, String>> () {
        
                @Override
                public void accept (Map.Entry<String, String> stringStringEntry) {
        
                    String key = stringStringEntry.getKey ();
                    String value = stringStringEntry.getValue ();
                    System.out.println (key + " - " + value);
                }
            });
    
            entries.forEach ((entry)->{
        
                String key = entry.getKey ();
                String value = entry.getValue ();
                System.out.println (key + " - " + value);
            });
    
            entries.forEach (entry-> System.out.println (entry.getKey ()+ " - " +entry.getValue ()));
    
            Iterator<Map.Entry<String,String>> it = entries.iterator ();
            while (it.hasNext ()){
        
                String key = it.next ().getKey ();
                String value = it.next ().getValue ();
                System.out.println (key + " - " + value);
            }
    
        }
    }

#### Lambda表达式 ####

default void forEach(BiConsumer<? super K,? super V> action)   结合lambda遍历Map集合

package com.map;
    
    import java.util.HashMap;
    import java.util.Map;
    import java.util.function.BiConsumer;
    
    public class MapDemo04 {
        
        public static void main (String[] args) {
        
    
    
            //1. 创建对象
            Map<String,String> map = new HashMap<> ();
    
            /*
            2. 添加元素
                键：人物名字
                值：名人名言
             */
            map.put ("鲁迅","这句话不是我说的");
            map.put ("曹操","不可能绝对不可能");
            map.put ("刘备","接着奏乐接着舞");
            map.put ("柯镇恶","看我眼色行事");
            
            //3. 利用lambda表达式遍历
            map.forEach (new BiConsumer<String, String> () {
        
                @Override
                public void accept (String key, String value) {
        
                    System.out.println (key + " - " + value);
                }
            });
            map.forEach ((key,value)-> System.out.println (key + " - " + value));
        }
    }

### HashMap ###

特点：
    1. HashMap是Map的一个实现类
    2. 方法都是Map里面的方法
    3. 特点由键决定：无序、不重复。无索引
    4. HashMap与HashSet的底层原理是一样的，都是哈希表结构

#### 底层原理 ####

1.  HashMap底层是哈希表结构
2.  依赖hashCode方法和equals方法保证键的唯一
3.  如果键存储的是自定义对象，需要重写hashCode和equals方法
4.  如果值存储的是自定义对象，不需要重写hashCode和equals方法

#### 案例 ####

##### Map集合案例：存储学生对象并遍历 #####

需求：
    	创建一个HashMap集合，键是学生对象（Student），值是籍贯（String）
    	存储3个键值对对象，并遍历
    	要求：同姓名，同年龄认为是同一个学生

package com.map.hashmap;
    
    import java.util.HashMap;
    import java.util.Map;
    import java.util.function.BiConsumer;
    import java.util.function.Consumer;
    
    public class HashMapDemo01 {
        
        public static void main (String[] args) {
        
            /*
            需求：
    		创建一个HashMap集合，键是学生对象（Student），值是籍贯（String）
    		存储3个键值对对象，并遍历
    		要求：同姓名，同年龄认为是同一个学生
             */
            //1. 创建HashMap对象
            HashMap<Student,String> hm = new HashMap<> ();
    
            //2. 创建3个学生对象
            Student s1 = new Student ("张三",23);
            Student s2 = new Student ("李四",24);
            Student s3 = new Student ("王五",25);
    
            //3. 添加元素
            hm.put (s1,"河北");
            hm.put (s2,"湖南");
            hm.put (s3,"北京");
    
            //4. 遍历集合
            hm.entrySet ().forEach (new Consumer<Map.Entry<Student, String>> () {
        
                @Override
                public void accept (Map.Entry<Student, String> entry) {
        
                    Student key = entry.getKey ();
                    String value = entry.getValue ();
                    System.out.println (key + " - " + value);
                }
            });
    
            System.out.println ("-----------------------------------------------------------------");
            hm.entrySet ().forEach ((entry)-> System.out.println (entry.getKey () + " - " + entry.getValue ()));
    
            System.out.println ("-----------------------------------------------------------------");
            for (Student key : hm.keySet ()) {
        
                System.out.println (key + " - " + hm.get (key));
            }
            System.out.println ("-----------------------------------------------------------------");
            hm.forEach ((key,value)-> System.out.println (key + " - "+ value));
            System.out.println ("-----------------------------------------------------------------");
            hm.forEach (new BiConsumer<Student, String> () {
        
                @Override
                public void accept (Student key, String value) {
        
                    System.out.println (key + " - "+ value);
                }
            });
            System.out.println ("-----------------------------------------------------------------");
            hm.keySet ().forEach ((key)-> System.out.println (key+" - "+hm.get (key)));
        }
    }

##### Map集合案例：统计投票人数 #####

需求：
    	某个班级80名学生，现在需要组织秋游活动，班长提供了四个景点（A,B,C,D）每个学生只能选择一个景点，请统计出最终哪个景点想去的人数多

package com.map.hashmap;
    
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.Map;
    import java.util.Random;
    import java.util.function.BiConsumer;
    
    public class HashMapDemo02 {
        
        public static void main (String[] args) {
        
            /*
            需求：
    		某个班级80名学生，现在需要组织秋游活动，班长提供了四个景点（A,B,C,D）每个学生只能选择一个景点，请统计出最终哪个景点想去的人数多
             */
    
            //1. 先让同学投票
            //定义一个数组，存储4个点
            String[] arr = {
        "A","B","C","D"};
            //利用随机数，模拟80个同学投票，把投票的结果存储起来
            ArrayList<String> list = new ArrayList<> ();
            Random r = new Random ();
            for (int i = 0; i < 80; i++) {
        
                int index = r.nextInt (arr.length);
                //System.out.println (arr[index]);
                list.add (arr[index]);
            }
    
            //2. 定义一个map集合，利用集合进行统计（统计的东西比较多，就不适合使用计数思想）
            HashMap<String,Integer> hm = new HashMap<> ();
    
            //依次得到投票信息
            for (String name : list) {
        
                //判断当前景点，在集合中是否存在
                if (hm.containsKey (name)){
        
                    //存在
                    //获取当前景点已经投票的次数
                    int count = hm.get (name);
                    //当前景点又被投了一票
                    count++;
                    //把新的次数，添加到集合当中
                    hm.put (name,count);
                }else {
        
                    //不存在
                    hm.put (name,1);
                }
            }
            System.out.println (hm);
    
            //3. 求最大值
            int max = 0;
            for (Map.Entry<String, Integer> entry : hm.entrySet ()) {
        
                if (entry.getValue ()>max){
        
                    max = entry.getValue ();
                }
            }
            System.out.println (max);
    
            //4. 判断哪个景点的票数和最大值一样，打印
            for (Map.Entry<String, Integer> entry : hm.entrySet ()) {
        
                if (entry.getValue ()==max){
        
                    System.out.println (entry.getKey ());
                }
            }
            
        }
    }

### LinkedHashMap ###

由键决定：有序、不重复、无索引
    这里的有序指的是保证存储和取出的顺序一致
    原理：底层依旧是哈希表，只是每个键值对又额外的多了一个双链表的机制记录存储的顺序

package com.map.linkedhashmap;
    
    import java.util.LinkedHashMap;
    
    public class LinkedHashMapDemo01 {
        
        public static void main (String[] args) {
        
        /*
        由键决定：有序、不重复、无索引
    	这里的有序指的是保证存储和取出的顺序一致
    	原理：底层依旧是哈希表，只是每个键值对又额外的多了一个双链表的机制记录存储的顺序
         */
            //1. 创建集合
            LinkedHashMap<String,Integer> lhm = new LinkedHashMap<> ();
    
            //2. 添加元素
            lhm.put ("b",123);
            lhm.put ("a",123);
            lhm.put ("d",789);
            lhm.put ("c",456);
    
            //3. 打印集合
            System.out.println (lhm);
    
        }
    }

### TreeMap ###

1.  TreeMap跟TreeSet底层是一样的，都是红黑树结构
2.  由键决定特性：不重复、无索引、可排序
3.  可排序：对键进行排序
4.  注意：**默认按照从小到大进行排序，也可以自己规定排序规则**

##### 代码书写两种排序规则 #####

1. 实现Comparable接口，指定比较规则（默认）
    2. 创建集合时，传递Compartor比较器对象，指定比较规则
    3. 当我们两种方式都写了的时候，默认使用第二种

#### 案例 ####

1.      需求：
             键：表示id
             值：字符串表示商品名称
             要求：按照ID的升序排列、按照id的降序排列

package com.map.treemap;
    
    import java.util.Comparator;
    import java.util.TreeMap;
    
    public class TreeMapDemo01 {
        
        public static void main (String[] args) {
        
            /*
                需求：
                    键：表示id
                    值：字符串表示商品名称
                    要求：按照ID的升序排列、按照id的降序排列
             */
    
            TreeMap<Integer,String> tm = new TreeMap<> (new Comparator<Integer> () {
        
                @Override
                public int compare (Integer x, Integer y) {
        
                    //升序
                    //int i =  (x<y) ? -1 : ((x.equals (y)) ? 0 : 1);//o1-o2;
                    //降序
                    int i = (x>y) ? -1 : ((x.equals (y)) ? 0 : 1);//o2-o1
                    return i;
                }
            });
    
            tm.put (201901,"蛋糕");
            tm.put (201922,"雪糕");
            tm.put (201909,"枣糕");
            tm.put (201914,"蒸糕");
    
            System.out.println (tm);
    
    
        }
    }

1.  需求：  
    键：学生对象  
    值：籍贯  
    要求：按照学生年龄升序排序，年龄一样的按照姓名首字母排序，同姓名的视为同一人

package com.map.treemap;
    
    import java.util.TreeMap;
    
    public class TreeMapDemo02 {
        
        public static void main (String[] args) {
        
    
            TreeMap<Student,String> tm = new TreeMap<> ();
    
            Student s1 = new Student ("zhangsan", 23);
            Student s2 = new Student ("lisi", 24);
            Student s3 = new Student ("wangwu", 25);
    
            tm.put (s1,"河北");
            tm.put (s2,"北京");
            tm.put (s3,"天津");
    
            System.out.println (tm);
    
        }
    }

package com.map.treemap;
    
    public class Student implements Comparable<Student>{
        
        private String name;
        private int age;
    
        public Student () {
        
        }
    
        public Student (String name, int age) {
        
            this.name = name;
            this.age = age;
        }
    
        /**
         * 获取
         * @return name
         */
        public String getName () {
        
            return name;
        }
    
        /**
         * 设置
         * @param name
         */
        public void setName (String name) {
        
            this.name = name;
        }
    
        /**
         * 获取
         * @return age
         */
        public int getAge () {
        
            return age;
        }
    
        /**
         * 设置
         * @param age
         */
        public void setAge (int age) {
        
            this.age = age;
        }
    
        public String toString () {
        
            return "Student{name = " + name + ", age = " + age + "}";
        }
    
        @Override
        public int compareTo (Student o) {
        
            //按照学生年龄升序排序，年龄一样的按照姓名首字母排序，同姓名的视为同一人
            int i = this.getAge ()-o.getAge ();
            i = i == 0 ? this.getName ().compareTo (o.getName ()) : i;
            return i;
        }
    }

1.  需求：  
    字符串"aabacccbaabeb"  
    请统计字符串中每一个字符出现的次数，并按照以下格式输出  
    输出结果：  
    a(5)b(4)c(3)d(2)e(1)

package com.map.treemap;
    
    import java.util.StringJoiner;
    import java.util.TreeMap;
    import java.util.function.BiConsumer;
    
    public class TreeMapDemo03 {
        
        public static void main (String[] args) {
        
            /*
                3. 需求：
                字符串"aabacccbaabeb"
                请统计字符串中每一个字符出现的次数，并按照以下格式输出
                输出结果：
                    a(5)b(4)c(3)d(2)e(1)
    
                新的统计思想：利用map集合进行统计
    
                如果题目中没有要求对结果进行排序，默认使用HashMap
                如果题目中要求对结果进行排序，使用TreeMap
             */
    
            //1. 定义字符串
            String s = "aabacdccbadabeb";
    
            //2. 创建集合
            TreeMap<Character,Integer> tm = new TreeMap<> ();
    
            //3. 遍历字符串，得到里面的每一个字符
            for (int i = 0; i < s.length (); i++) {
        
                char c = s.charAt (i);
                //System.out.println (c);
    
                //拿着c判断集合中是否存在
                if (tm.containsKey (c)){
        
                    //存在
                    int count = tm.get (c);
                    count++;
                    tm.put (c,count);
                }else {
        
                    //不存在
                    tm.put (c,1);
                }
            }
    
            //4. 遍历集合,并按照指定格式拼接：
            // a(5)b(4)c(3)d(2)e(1)
           StringBuilder sb = new StringBuilder ();
    
            /*tm.forEach (new BiConsumer<Character, Integer> () {
                @Override
                public void accept (Character key, Integer value) {
                    sb.append (key).append ("(").append (value).append (")");
                }
            });*/
            tm.forEach ((key,value)->sb.append (key).append ("(").append (value).append (")"));
            System.out.println (sb);
    
            StringJoiner sj = new StringJoiner ("","","");//中间的间隔符号
            tm.forEach ((key,value)->sj.add (key+"").add ("(").add (value+"").add (")"));
            System.out.println (sj);
        }
    }

[05a05fad25e34cd489be8056c531e6ab.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/9eae2677d72d402f94e83c6f88c63f27.png