集合进阶（二）

YMHH12

已于 2023-12-18 20:33:02 修改

阅读量1.6k

点赞数 42

文章标签： java 算法开发语言

于 2023-12-16 18:43:16 首次发布

本文链接：https://blog.csdn.net/YMHH12/article/details/135035450

版权

可变参数

就是一种特殊形参，定义在方法、构造器的形参列表里，格式是：数据类型...参数名称；

可变参数的特点和好处：

特点：可以不传数据给它；可以传一个或者同时传多个数据给它；也可以传一个数组给它。

好处：常常用来灵活的接收数据。

可变参数的注意事项：

可变参数在方法内部就是一个数组。

一个形参列表中可变参数只能有一个。

可变参数必须放在形参列表的最后面。

       public static void main(String[] args) {
        // 特点：
        test(); // 不传数据
        test(10); // 传输一个数据给它
        test(10, 20, 30); // 传输多个数据给它
        test(new int[]{10, 20, 30, 40}); // 传输一个数组给可变参数
    }

    // 注意事项1：一个形参列表中，只能有一个可变参数。
    // 注意事项2：可变参数必须放在形参列表的最后面
    public static void test(int...nums){
        // 可变参数在方法内部，本质就是一个数组。
        System.out.println(nums.length);
        System.out.println(Arrays.toString(nums));
        System.out.println("-----------------------------------------");
    }

Collections

是一个用来操作集合的工具类.

Collections提供的常用静态方法

Collections只能支持对List集合进行排序

排序方式1：

排序方式2：

        public static void main(String[] args) {
        // 1、public static <T> boolean addAll(Collection<? super T> c, T...elements)：为集合批量添加数据
        List<String> names = new ArrayList<>();
        Collections.addAll(names, "张三", "王五", "李四", "张麻子");
        System.out.println(names);

        // 2、public static void shuffle(List<?> list)：打乱List集合中的元素顺序。
        Collections.shuffle(names);
        System.out.println(names);

        // 3、 public static <T> void sort(List<T> list)：对List集合中的元素进行升序排序。
        List<Integer> list = new ArrayList<>();
        list.add(3);
        list.add(5);
        list.add(2);
        Collections.sort(list);
        System.out.println(list);

        List<Student> students = new ArrayList<>();
        students.add(new Student("蜘蛛精",23, 169.7));
        students.add(new Student("紫霞",22, 169.8));
        students.add(new Student("紫霞",22, 169.8));
        students.add(new Student("至尊宝",26, 165.5));
        // Collections.sort(students);
        // System.out.println(students);

        // 4、public static <T> void sort(List<T> list， Comparator<? super T> c): 对List集合中元素，按照比较器对象指定的规则进行排序
        Collections.sort(students, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return Double.compare(o1.getHeight(), o2.getHeight());
            }
        });
        System.out.println(students);
    }

Map集合

认识Map集合

1. Map集合称为双列集合，格式：{key1=value1 , key2=value2 , key3=value3 , ...}，一次需要存一对数据做为一个元素。

2.Map集合的每个元素“key=value”称为一个键值对/键值对对象/一个Entry对象，Map集合也被叫做“键值对集合”

3.Map集合的所有键是不允许重复的，但值可以重复，键和值是一一对应的，每一个键只能找到自己对应的值

Map集合在什么业务场景下使用

需要存储一一对应的数据时，就可以考虑使用Map集合来做。

Map集合体系

Map体系集合的特点：

注意：Map系列集合的特点都是由键决定的，值只是一个附属品，值是不做要求的

HashMap（由键决定特点）: 无序、不重复、无索引；（用的最多）

LinkedHashMap （由键决定特点）:由键决定的特点：有序、不重复、无索引。

TreeMap （由键决定特点）:按照大小默认升序排序、不重复、无索引。

为什么要先学习Map的常用方法 ?

Map是双列集合的祖宗，它的功能是全部双列集合都可以继承过来使用的。

Map的常用方法如下：

entrySet()方法，可以将Map集合转成Set集合。

Map集合的遍历方式：

键找值

先获得Map集合全部的键，再通过遍历键来找值。

需要用到的方法：

键值对

把键值对看成一个整体进行遍历（难度较大）。

       Map<String, Double> map = new HashMap<>();
        map.put("蜘蛛精", 169.8);
        map.put("紫霞", 165.8);
        map.put("至尊宝", 169.5);
        map.put("牛魔王", 183.6);
        System.out.println(map);
        // map = {蜘蛛精=169.8, 牛魔王=183.6, 至尊宝=169.5, 紫霞=165.8}
        // entries = [(蜘蛛精=169.8), (牛魔王=183.6), (至尊宝=169.5), (紫霞=165.8)]
        //                entry                                        

        // 1、调用Map集合提供entrySet方法，把Map集合转换成键值对类型的Set集合
        Set<Map.Entry<String, Double>> entries = map.entrySet();
        for (Map.Entry<String, Double> entry : entries) {
            String key = entry.getKey();
            double value = entry.getValue();
            System.out.println(key + "---->" + value);
        }
    }

Lambda

需要用到的Map方法如下：

        public static void main(String[] args) {
        Map<String, Double> map = new HashMap<>();
        map.put("蜘蛛精", 169.8);
        map.put("紫霞", 165.8);
        map.put("至尊宝", 169.5);
        map.put("牛魔王", 183.6);
        System.out.println(map);
        // map = {蜘蛛精=169.8, 牛魔王=183.6, 至尊宝=169.5, 紫霞=165.8}

//        map.forEach((k, v) -> {
//            System.out.println(k + "--->" + v);
//        });

//        map.forEach(new BiConsumer<String, Double>() {
//            @Override
//            public void accept(String k, Double v) {
//                System.out.println(k + "---->" + v);
//            }
//        });

        map.forEach(( k,  v) -> {
              System.out.println(k + "---->" + v);
        });
    }

案例

       public static void main(String[] args) {
        // 1、把80个学生选择的景点数据拿到程序中来。
        List<String> data = new ArrayList<>();
        String[] selects = {"A", "B", "C", "D"};
        Random r = new Random();
        for (int i = 1; i <= 80; i++) {
            // 每次模拟一个学生选择一个景点，存入到集合中去。
            int index = r.nextInt(4); // 0 1 2 3
            data.add(selects[index]);
        }
        System.out.println(data);

        // 2、开始统计每个景点的投票人数
        // 准备一个Map集合用于统计最终的结果
        Map<String, Integer> result = new HashMap<>();

        // 3、开始遍历80个景点数据
        for (String s : data) {
            // 问问Map集合中是否存在该景点
            if(result.containsKey(s)){
                // 说明这个景点之前统计过。其值+1. 存入到Map集合中去
                result.put(s, result.get(s) + 1);
            }else {
                // 说明这个景点是第一次统计，存入"景点=1"
                result.put(s, 1);
            }
        }
        System.out.println(result);
    }

HashMap集合的底层原理

由键决定的特点，无序、不重复、无索引

HashMap跟HashSet的底层原理是一模一样的，都是基于哈希表实现的。

实际上：原来学的Set系列集合的底层就是基于Map实现的，只是Set集合中的元素只要键数据，不要值数据而已。

哈希表

JDK8之前，哈希表 = 数组+链表。

JDK8开始，哈希表 = 数组+链表+红黑树。

哈希表是一种增删改查数据，性能都较好的数据结构。

利用“键”计算哈希值，与“值”无关。

HashMap底层是基于哈希表实现的

1.HashMap集合是一种增删改查数据，性能都较好的集合。

2.但是它是无序，不能重复，没有索引支持的（由键决定特点）。

3.HashMap的键依赖hashCode方法和equals方法保证键的唯一。

4.如果键存储的是自定义类型的对象，可以通过重写hashCode和equals方法，这样可以保证多个对象内容一样时，HashMap集合就能认为是重复的。

LinkedHashMap集合的原理

由键决定的特点：有序、不重复、无索引

底层数据结构依然是基于哈希表实现的，只是每个键值对元素又额外的多了一个双链表的机制记录元素顺序(保证有序)。

实际上：原来学习的LinkedHashSet集合的底层原理就是LinkedHashMap。

TreeMap集合的原理

特点：不重复、无索引、可排序(按照键的大小默认升序排序，只能对键排序)

原理：TreeMap跟TreeSet集合的底层原理是一样的，都是基于红黑树实现的排序。

TreeMap集合同样也支持两种方式来指定排序规则

1.让类实现Comparable接口，重写比较规则。

2.TreeMap集合有一个有参数构造器，支持创建Comparator比较器对象，以便用来指定比较规则。

//        Map<Student,String> map=new TreeMap<>(new Comparator<Student>() {
//            @Override
//            public int compare(Student o1, Student o2) {
//                return Double.compare(o2.getHeight(),o1.getHeight());
//            }
//        });
        Map<Student,String> map=new TreeMap<>(( o1,  o2) -> Double.compare(o2.getHeight(),o1.getHeight()));
        map.put(new Student("蜘蛛精", 168.5,25 ), "盘丝洞");
        map.put(new Student("蜘蛛精", 168.5,25 ), "水帘洞");
        map.put(new Student("至尊宝", 163.5,23 ), "水帘洞");
        map.put(new Student("牛魔王", 183.5,28 ), "牛头山");
        System.out.println(map);