HashMap&LinkedHashMap&TreeMap

灰太狼 2024-03-31 08:49 68阅读 0赞

### HashMap的特点： ###

*  HashMap是Map的实现类；
 *  没有额外需要学习的方法，直接使用Map里面的方法就可以了；
 *  特点都是由键决定的：无序、不重复、无索引；
 *  HashMap跟HashSet地底层原理是一摸一样的，都是哈希表结构。

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

import java.util.Objects;
    
    public class HashMapStudent {
        private String name;
        private Integer age;
    
        public HashMapStudent() {
        }
    
        public HashMapStudent(String name, Integer 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 Integer getAge() {
            return age;
        }
    
        /**
         * 设置
         * @param age
         */
        public void setAge(Integer age) {
            this.age = age;
        }
    
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            HashMapStudent that = (HashMapStudent) o;
            return Objects.equals(name, that.name) && Objects.equals(age, that.age);
        }
    
        @Override
        public int hashCode() {
            return Objects.hash(name, age);
        }
    
        public String toString() {
            return "HashMapStudent{name = " + name + ", age = " + age + "}";
        }
    }

import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Map;
    import java.util.Set;
    
    
    public class HashMapDemo {
        public static void main(String[] args) {
    
            //创建一个HashMap集合，键是学生对象（Student），值是籍贯（String）
            HashMap<HashMapStudent,String> hm = new HashMap<>();
    
            //添加学生对象
            HashMapStudent s1 = new HashMapStudent("张三", 25);
            HashMapStudent s2 = new HashMapStudent("李四", 22);
            HashMapStudent s3 = new HashMapStudent("王五", 23);
            HashMapStudent s4 = new HashMapStudent("王五", 23);
    
            //添加元素
            hm.put(s1,"江苏");
            hm.put(s2,"安徽");
            hm.put(s3,"浙江");
            hm.put(s4,"河南");
    
            //遍历集合
            Set<HashMapStudent> keys = hm.keySet();
            for (HashMapStudent key : keys) {
                String value = hm.get(key);
                System.out.println(key+":"+value);
            }
            System.out.println("---------------------------");
            Iterator<HashMapStudent> iterator = keys.iterator();
            while (iterator.hasNext()){
                HashMapStudent next = iterator.next();
                String value = hm.get(next);
                System.out.println(next+":"+value);
            }
            System.out.println("---------------------------");
            Set<Map.Entry<HashMapStudent, String>> entries = hm.entrySet();
            for (Map.Entry<HashMapStudent, String> entry : entries) {
                HashMapStudent key = entry.getKey();
                String value = entry.getValue();
                System.out.println(key+":"+value);
            }
            System.out.println("---------------------------");
            Iterator<Map.Entry<HashMapStudent, String>> iterator1 = entries.iterator();
            while (iterator1.hasNext()){
                Map.Entry<HashMapStudent, String> next = iterator1.next();
                HashMapStudent key = next.getKey();
                String value = next.getValue();
                System.out.println(key+":"+value);
            }
        }
    }

输出结果：几种遍历方法结果相同

![5ddc8fa605de4b939fa5633902d4a6f1.png][]

> 核心点：
> 
> HashMap的键位置如果存储的是自定义对象，需要重写hashCode和equals方法。

案例二：

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

import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.Map;
    import java.util.Random;
    import java.util.Set;
    
    /**
     * 需求
     * 某个班级80名学生，现在需要组织秋游活动，班长提供了四个景点依次是（A、B、C、D），每个学生只能选择一个景点，请统计出最终那个景点想去的人最多。
     */
    public class HashMapDemo02 {
        public static void main(String[] args) {
            //投票
            //定义一个数组，存储四个景点
            String[] arr = {"A", "B", "C", "D"};
            //利用随机数模拟80个童鞋投票，并把投票的结果存储起来；
            ArrayList<String> list = new ArrayList<>();
            Random random = new Random();
            for (int i = 0; i < 80; i++) {
                int index = random.nextInt(arr.length);
                list.add(arr[index]);
            }
    
            //如果要统计的对象比较多，不方便统计
            //可以用map集合进行统计
            HashMap<String, Integer> hm = new HashMap<>();
            for (String name : list) {
                //判断当前景点是否在map集合中存在
                if (hm.containsKey(name)) {
                    //已经存在
                    //先获取当前景点已经被投票的次数
                    Integer count = hm.get(name);
                    //表示当前景点又被投了一次
                    count++;
                    //把新的次数再次添加到集合中
                    hm.put(name, count);
                } else {
                    //不存在
                    hm.put(name, 1);
                }
            }
            System.out.println(hm);
    
            //求最大值
            int max = 0;
            //遍历
            Set<Map.Entry<String, Integer>> entries = hm.entrySet();
            for (Map.Entry<String, Integer> entry : entries) {
                Integer value = entry.getValue();
                if (value>max){
                    max = value;
                }
            }
    
            //判断那个景点的次数和最大值一样，如果一样就打印出来
            for (Map.Entry<String, Integer> entry : entries) {
                Integer value = entry.getValue();
                if (value==max){
                    System.out.println(entry.getKey()+"景点的票数最多:共"+max+"票");
                }
            }
        }
    }

输出结果：

![47b1a911b16a468e8acb98ed5aab9ccd.png][]

### LinkedHashMap的特点： ###

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

import java.util.LinkedHashMap;
    
    public class LinkedHashMapDemo {
        public static void main(String[] args) {
            //创建集合
            LinkedHashMap<String, Integer> lhm = new LinkedHashMap<>();
            //添加元素
            lhm.put("a",123);
            lhm.put("c",456);
            lhm.put("b",789);
            lhm.put("a",666);
    
            //打印集合
            System.out.println(lhm);
        }
    }

输出结果：

![dfe67fc816e14b9b8f478eabe854a776.png][]

### TreeMap的特点： ###

*  TreeMap跟TreeSet底层原理是一样的；
 *  由键决定特性：可排序、不重复、无索引；
 *  可排序：对键进行排序；
 *  注意：默认按照键的从小到大排序，也可以自己规定键的排序规则。

**代码书写两种排序规则：**

*  实现Comparable接口，指定比较规则；
 *  创建集合时传递Comparator比较器对象，指定比较规则。

import java.util.TreeMap;
    
    public class TreeMapDemo {
        public static void main(String[] args) {
            //创建集合对象
            TreeMap<Integer,String> tm = new TreeMap<>();
            //添加元素
            tm.put(1,"粤利粤");
            tm.put(2,"康帅傅");
            tm.put(5,"可恰可乐");
            tm.put(3,"六个核弹");
            tm.put(4,"雷碧");
            tm.put(4,"雷碧");
    
            //打印集合
            System.out.println(tm);
        }
    }

输出结果：

![11cd473dad0b43d384d67debd1780462.png][]

> Integer Double： 默认情况下都是按照升序排序的；
> 
> String ：按照字母在ASCII码表中对应的数字升序进行排序

**创建集合时传递Comparator比较器对象，指定比较规则**

![2dd6c357ca844ceb83b6e23ef06995d4.png][]

**实现Comparable接口，指定比较规则**

![2fd5bd56ed6c45b49a053f63f107f983.png][]

public class TreeMapDemo2Student implements Comparable<TreeMapDemo2Student>{
        private String name;
        private Integer age;
        
        @Override
        public int compareTo(TreeMapDemo2Student o) {
            //需求：按照学生的年龄升序排序，年龄一样就按照名字的字母排序，同名同龄示为同一个学生
            int i = this.getAge() - o.getAge();
            i = i == 0 ? this.getName().compareTo(o.getName()) : i;
            return i;
        }
    
    
        public TreeMapDemo2Student() {
        }
    
        public TreeMapDemo2Student(String name, Integer 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 Integer getAge() {
            return age;
        }
    
        /**
         * 设置
         * @param age
         */
        public void setAge(Integer age) {
            this.age = age;
        }
    
        public String toString() {
            return "TreeMapDemo2Student{name = " + name + ", age = " + age + "}";
        }
    
    
    }

import java.util.TreeMap;
    
    public class TreeMapDemo2 {
        public static void main(String[] args) {
            TreeMap<TreeMapDemo2Student,String> tm =new TreeMap<>();
            TreeMapDemo2Student s1 = new TreeMapDemo2Student("zhangsan", 23);
            TreeMapDemo2Student s2 = new TreeMapDemo2Student("lisi", 25);
            TreeMapDemo2Student s3 = new TreeMapDemo2Student("wangwu", 24);
    
            tm.put(s1,"江苏");
            tm.put(s2,"安徽");
            tm.put(s3,"河南");
    
            System.out.println(tm);
        }
    }

输出结果：

![04807d1cd4334525ae88330aae9249ec.png][]

**TreeMap练习：**

统计字符串“abcdeecbdaaccceedb”每一个字符出现的次数

按照以下格式输出a（）b（）c（）.....

import java.util.Map;
    import java.util.Set;
    import java.util.TreeMap;
    
    public class TreeMapDemo3 {
        public static void main(String[] args) {
           
            //定义字符串
            String s = "abcdeecbdaaccceedecbdaaccb";
    
            //创建集合
            TreeMap<Character,Integer> tm = new TreeMap<>();
    
            //遍历字符串得到每一个字符
            for (int i = 0; i < s.length(); i++) {
                char c = s.charAt(i);
    //            System.out.println(c);
                //将c放到集合中判断是否存在
                //存在，表示当前字符又出现一次
                //不存在则表示当前字符第一次出现
                if (tm.containsKey(c)){
                    //存在
                    Integer count = tm.get(c);
                    //当前字符又出现一次
                    count++;
                    //把新的结果添加到集合中
                    tm.put(c,count);
                }else {
                    //不存在
                    tm.put(c,1);
                }
            }
            //打印遍历集合
            StringBuilder sb = new StringBuilder();
            Set<Map.Entry<Character, Integer>> entries = tm.entrySet();
            for (Map.Entry<Character, Integer> entry : entries) {
                Character key = entry.getKey();
                Integer value = entry.getValue();
                sb.append(key).append("(").append(value).append(")  ");
            }
            System.out.println(sb);
        }
    }

输出结果：

![e97088fc6b7541f2be94086623761f13.png][]

[5ddc8fa605de4b939fa5633902d4a6f1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/4753694d3a5c4260a16ee5edd5a44f0c.png
[47b1a911b16a468e8acb98ed5aab9ccd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/f294bad7184c4ebfbacbf8c1d222b027.png
[dfe67fc816e14b9b8f478eabe854a776.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/e2e563a42cec4e4983b32ddf56d41c1f.png
[11cd473dad0b43d384d67debd1780462.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/5e8020e4933544a783470a20711e96bf.png
[2dd6c357ca844ceb83b6e23ef06995d4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/1bfb64554abd4a74b5f1e3416f5d7e5a.png
[2fd5bd56ed6c45b49a053f63f107f983.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/f4f26ff64c324f51abd799311d128860.png
[04807d1cd4334525ae88330aae9249ec.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/833729918b77444d94a2d84d4bea2672.png
[e97088fc6b7541f2be94086623761f13.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/01c394c44a1944fba3d4df61e829e6a7.png

HashMap&LinkedHashMap&TreeMap

发表评论取消回复

还没有评论，来说两句吧...

相关阅读