day17——Java集合进阶（Collections、Map）

人生在勤，不索何获-白大侠2025-07-12 16:34

文章目录

一、可变参数：灵活的数据接收方式

可变参数 ：

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

可变参数的特点和好处

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

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

可变参数的注意事项 ：

可变参数在方法内部就是一个数组。
一个形参列表中可变参数只能有一个

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

java 复制代码 
public static void sum(int... nums) {
    int total = 0;
    for (int num : nums) {
        total += num;
    }
    System.out.println("Sum: " + total);
}

// 使用示例
sum();          // 不传参数
sum(10);        // 传1个参数
sum(10, 20);    // 传多个参数
sum(new int[]{10, 20, 30}); // 传数组

关键特性：

  1. 本质是数组：方法内部通过数组操作参数
  2. 位置限制：必须位于参数列表末尾
  3. 数量限制：一个方法只能有一个可变参数
  4. 灵活传参：支持0-N个参数或直接传递数组

实际应用场景：Collections.addAll() 方法就使用了可变参数，能灵活添加任意数量的元素到集合中

二、Collections工具类：集合操作的瑞士军刀

Collections提供了一系列静态方法操作集合，以下是核心功能：

常用方法：

java 复制代码 
List<String> list = new ArrayList<>();
// 1. 批量添加元素
Collections.addAll(list, "A", "B", "C");

// 2. 随机打乱顺序
Collections.shuffle(list);

// 3. 排序（默认升序）
Collections.sort(list);

// 4. 自定义排序
Collections.sort(list, (s1, s2) -> s2.compareTo(s1));

排序注意事项：

  • 基本类型和String可直接排序
  • 自定义对象需实现Comparable接口
  • 或通过Comparator指定排序规则

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

  • 排序方式1

    注意：本方法可以直接对自定义类型的List集合排序，但自定义类型必须实现了Comparable接口，指定了比较规则才可以。

  • 排序方式2

三、Map集合体系：键值对存储的王者

Map存储键值对（key-value）数据，核心特点：键唯一，值可重复

1. Map体系结构
2. 三大实现类对比
特性 HashMap LinkedHashMap TreeMap
顺序 无序 插入顺序 自然排序
底层结构 哈希表 哈希表+链表 红黑树
线程安全 否 否 否
允许null键 是 是 否（需比较）
性能 O(1) O(1) O(log n)
3. Map集合的常用方法
java 复制代码 
       // 1.添加元素: 无序，不重复，无索引。
        Map<String, Integer> map = new HashMap<>();
        map.put("手表", 100);
        map.put("手表", 220);
        map.put("手机", 2);
        map.put("Java", 2);
        map.put(null, null);
        System.out.println(map);
        // map = {null=null, 手表=220, Java=2, 手机=2}

        // 2.public int size():获取集合的大小
        System.out.println(map.size());

        // 3、public void clear():清空集合
        //map.clear();
        //System.out.println(map);

        // 4.public boolean isEmpty(): 判断集合是否为空，为空返回true ,反之！
        System.out.println(map.isEmpty());

        // 5.public V get(Object key)：根据键获取对应值
        int v1 = map.get("手表");
        System.out.println(v1);
        System.out.println(map.get("手机")); // 2
        System.out.println(map.get("张三")); // null

        // 6. public V remove(Object key)：根据键删除整个元素(删除键会返回键的值)
        System.out.println(map.remove("手表"));
        System.out.println(map);

        // 7.public  boolean containsKey(Object key): 判断是否包含某个键 ，包含返回true ,反之
        System.out.println(map.containsKey("手表")); // false
        System.out.println(map.containsKey("手机")); // true
        System.out.println(map.containsKey("java")); // false
        System.out.println(map.containsKey("Java")); // true

        // 8.public boolean containsValue(Object value): 判断是否包含某个值。
        System.out.println(map.containsValue(2)); // true
        System.out.println(map.containsValue("2")); // false

        // 9.public Set<K> keySet(): 获取Map集合的全部键。
        Set<String> keys = map.keySet();
        System.out.println(keys);

        // 10.public Collection<V> values(); 获取Map集合的全部值。
        Collection<Integer> values = map.values();
        System.out.println(values);

        // 11.把其他Map集合的数据倒入到自己集合中来。(拓展)
        Map<String, Integer> map1 = new HashMap<>();
        map1.put("java1",  10);
        map1.put("java2",  20);
        Map<String, Integer> map2 = new HashMap<>();
        map2.put("java3",  10);
        map2.put("java2",  222);
        map1.putAll(map2); 
        // putAll：把map2集合中的元素全部倒入一份到map1集合中去。
        System.out.println(map1);
        System.out.println(map2);
4. Map集合的三种遍历方式

方式1：键找值（keySet）

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

需要用到Map的如下方法：

java 复制代码 
for (String key : map.keySet()) {
    System.out.println(key + "=" + map.get(key));
}

方式2：键值对（entrySet）

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


java 复制代码 
for (Map.Entry<String, Integer> entry : map.entrySet()) {
    System.out.println(entry.getKey() + "=" + entry.getValue());
}

方式3：Lambda表达式（推荐）

JDK 1.8开始之后的新技术（非常的简单）

java 复制代码 
map.forEach((k, v) -> 
    System.out.println(k + "=" + v));
5. HashMap底层原理

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

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

哈希表

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

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

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

java 复制代码 
Map<String, Integer> map = new HashMap<>();
map.put("key", 1); // 触发存储过程

存储流程：

  1. 首次添加时创建长度16的数组
  2. 计算键的hashCode（通过hash()方法扰动）
  3. 通过(n-1) & hash计算索引位置
  4. 处理哈希冲突：
    • 链表长度<8：尾插法
    • 链表长度≥8且数组长度≥64：转红黑树
  5. 扩容机制：元素数量超过阈值（容量*0.75）时扩容2倍

重要特性：

  • 自定义对象作为键时，必须重写hashCode()和equals()
  • 哈希冲突解决方案：链表→红黑树
  • 加载因子0.75平衡时间和空间效率
6. LinkedHashMap 底层原理

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

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

7. TreeMap 底层原理

特点 ：不重复、无索引、可排序(按照键的大小默认升序排序，只能对键排序)
原理：TreeMap跟TreeSet集合的底层原理是一样的，都是基于红黑树实现的排序。

TreeMap集合同样也支持两种方式来指定自定义排序规则
方式一 ：让类实现Comparable接口，重写比较规则。

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

java 复制代码 
 Map<Student, String> map = new TreeMap<>(new Comparator<Student>()--> Double.compare(o2.getHeight(), o1.getHeight()) {
            @Override
            public int compare(Student o1, Student o2) {
                return Double.compare(o2.getHeight(), o1.getHeight());
            }
        });
简化lambda表达式：
 Map<Student, String> map = new TreeMap<>((o1, o2) {
                Double.compare(o2.getHeight(), o1.getHeight());
        });
8. 集合嵌套：复杂数据结构的解决方案

集合嵌套指的是集合里的元素又是一个集合

java 复制代码 
/**
 * 目标：理解集合的嵌套。
 * 江苏省 = "南京市","扬州市","苏州市","无锡市","常州市"
 * 湖北省 = "武汉市","孝感市","十堰市","宜昌市","鄂州市"
 * 河北省 = "石家庄市","唐山市", "邢台市", "保定市", "张家口市"
 */
public class Test {
    public static void main(String[] args) {
        // 1、定义一个Map集合存储全部的省份信息，和其对应的城市信息。
        Map<String, List<String>> map = new HashMap<>();

        List<String> cities1 = new ArrayList<>();
        Collections.addAll(cities1, "南京市","扬州市","苏州市" ,"无锡市","常州市");
        map.put("江苏省", cities1);

        List<String> cities2 = new ArrayList<>();
        Collections.addAll(cities2, "武汉市","孝感市","十堰市","宜昌市","鄂州市");
        map.put("湖北省", cities2);

        List<String> cities3 = new ArrayList<>();
        Collections.addAll(cities3, "石家庄市","唐山市", "邢台市", "保定市", "张家口市");
        map.put("河北省", cities3);
        System.out.println(map);

        List<String> cities = map.get("湖北省");
        for (String city : cities) {
            System.out.println(city);
        }

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

实际应用：电商系统的商品分类、省市区三级联动等场景

四、Stream流：集合操作的现代化处理

Stream API（JDK8+）提供声明式数据处理能力，极大提升代码简洁性

java 复制代码 
/**
   目标：初步体验Stream流的方便与快捷
 */
public class StreamTest1 {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        Collections.addAll(names, "张三丰","张无忌","周芷若","赵敏","张强");
        System.out.println(names);
        // names = [张三丰, 张无忌, 周芷若, 赵敏, 张强]
        //          name

        // 找出姓张，且是3个字的名字，存入到一个新集合中去。
        List<String> list = new ArrayList<>();
        for (String name : names) {
            if(name.startsWith("张") && name.length() == 3){
                list.add(name);
            }
        }
        System.out.println(list);

        // 开始使用Stream流来解决这个需求。
        List<String> list2 = names.stream().filter(s -> s.startsWith("张"))
                .filter(a -> a.length()==3).collect(Collectors.toList());
        System.out.println(list2);
    }


1. 创建Stream的四种方式

方式一 ：获取 集合 的Stream流

java 复制代码 
 // 1、如何获取List集合的Stream流？
        List<String> names = new ArrayList<>();
        Collections.addAll(names, "张三丰","张无忌","周芷若","赵敏","张强");
        Stream<String> stream = names.stream();

        // 2、如何获取Set集合的Stream流？
        Set<String> set = new HashSet<>();
        Collections.addAll(set, "刘德华","张曼玉","蜘蛛精","马德","德玛西亚");
        Stream<String> stream1 = set.stream();
        stream1.filter(s -> s.contains("德")).forEach(s -> System.out.println(s));

方式二： Map集合创建

java 复制代码 
  // 3、如何获取Map集合的Stream流？
        Map<String, Double> map = new HashMap<>();
        map.put("古力娜扎", 172.3);
        map.put("迪丽热巴", 168.3);
        map.put("马尔扎哈", 166.3);
        map.put("卡尔扎巴", 168.3);
        
        Set<String> keys = map.keySet();  //获取键
        Stream<String> ks = keys.stream();

        Collection<Double> values = map.values(); // 获取值
        Stream<Double> vs = values.stream();

        Set<Map.Entry<String, Double>> entries = map.entrySet(); //获取键值对
        Stream<Map.Entry<String, Double>> kvs = entries.stream();
        kvs.filter(e -> e.getKey().contains("巴"))
                .forEach(e -> System.out.println(e.getKey()+ "-->" + e.getValue()));

方式三 ：数组创建

获取 数组 的Stream流

java 复制代码 
String[] arr = {"A", "B"};
Stream<String> stream2 = Arrays.stream(arr);

方式四 ：直接创建

java 复制代码 
Stream<String> stream3 = Stream.of("A", "B");
2. 中间操作：构建处理流水线

中间方法返回新Stream，支持链式调用

方法 功能描述 示例
filter() 条件过滤 stream.filter(s -> s.length()>3)
map() 元素转换 stream.map(String::toUpperCase)
sorted() 排序 stream.sorted(Comparator.reverseOrder())
distinct() 去重 stream.distinct()
limit() 限制元素数量 stream.limit(5)
skip() 跳过前N个元素 stream.skip(2)
java 复制代码 
/**
 * 目标：掌握Stream流提供的常见中间方法。
 */
public class StreamTest3 {
    public static void main(String[] args) {
        List<Double> scores = new ArrayList<>();
        Collections.addAll(scores, 88.5, 100.0, 60.0, 99.0, 9.5, 99.6, 25.0);
        // 需求1：找出成绩大于等于60分的数据，并升序后，再输出。
        scores.stream().filter(s -> s >= 60).sorted().forEach(s -> System.out.println(s));

        List<Student> students = new ArrayList<>();
        Student s1 = new Student("蜘蛛精", 26, 172.5);
        Student s2 = new Student("蜘蛛精", 26, 172.5);
        Student s3 = new Student("紫霞", 23, 167.6);
        Student s4 = new Student("白晶晶", 25, 169.0);
        Student s5 = new Student("牛魔王", 35, 183.3);
        Student s6 = new Student("牛夫人", 34, 168.5);
        Collections.addAll(students, s1, s2, s3, s4, s5, s6);
        // 需求2：找出年龄大于等于23,且年龄小于等于30岁的学生，并按照年龄降序输出.
        students.stream().filter(s -> s.getAge() >= 23 && s.getAge() <= 30)
                .sorted((o1, o2) -> o2.getAge() - o1.getAge())
                .forEach(s -> System.out.println(s));

        // 需求3：取出身高最高的前3名学生，并输出。
        students.stream().sorted((o1, o2) -> Double.compare(o2.getHeight(), o1.getHeight()))
                .limit(3).forEach(System.out::println);
        System.out.println("----------------------------------------------------------------");

        // 需求4：取出身高倒数的2名学生，并输出。   s1 s2 s3 s4 s5 s6
        students.stream().sorted((o1, o2) -> Double.compare(o2.getHeight(), o1.getHeight()))
                .skip(students.size() - 2).forEach(System.out::println);

        // 需求5：找出身高超过168的学生叫什么名字，要求去除重复的名字，再输出。
        students.stream().filter(s -> s.getHeight() > 168).map(Student::getName)
               .distinct().forEach(System.out::println);

        // distinct去重复，自定义类型的对象（希望内容一样就认为重复，重写hashCode,equals）
        students.stream().filter(s -> s.getHeight() > 168)
                .distinct().forEach(System.out::println);

        Stream<String> st1 = Stream.of("张三", "李四");
        Stream<String> st2 = Stream.of("张三2", "李四2", "王五");
        Stream<String> allSt = Stream.concat(st1, st2);
        allSt.forEach(System.out::println);
    }
}
3. 终结操作：获取最终结果

终结操作后流不可再用


方法 返回类型 示例
forEach() void stream.forEach(System.out::println)
count() long stream.count()
collect() Collection stream.collect(Collectors.toList())
max/min() Optional stream.max(Comparator.naturalOrder())
toArray() Object[] stream.toArray(String[]::new)
java 复制代码 
/**
 * 目标：Stream流的终结方法
 */
public class StreamTest4 {
    public static void main(String[] args) {
        List<Student> students = new ArrayList<>();
        Student s1 = new Student("蜘蛛精", 26, 172.5);
        Student s2 = new Student("蜘蛛精", 26, 172.5);
        Student s3 = new Student("紫霞", 23, 167.6);
        Student s4 = new Student("白晶晶", 25, 169.0);
        Student s5 = new Student("牛魔王", 35, 183.3);
        Student s6 = new Student("牛夫人", 34, 168.5);
        Collections.addAll(students, s1, s2, s3, s4, s5, s6);
        // 需求1：请计算出身高超过168的学生有几人。
        long size = students.stream().filter(s -> s.getHeight() > 168).count();
        System.out.println(size);

        // 需求2：请找出身高最高的学生对象，并输出。
        Student s = students.stream().max((o1, o2) -> Double.compare(o1.getHeight(), o2.getHeight())).get();
        System.out.println(s);

        // 需求3：请找出身高最矮的学生对象，并输出。
        Student ss = students.stream().min((o1, o2) -> Double.compare(o1.getHeight(), o2.getHeight())).get();
        System.out.println(ss);

        // 需求4：请找出身高超过170的学生对象，并放到一个新集合中去返回。
        // 流只能收集一次。
        List<Student> students1 = students.stream().filter(a -> a.getHeight() > 170).collect(Collectors.toList());
        System.out.println(students1);

        Set<Student> students2 = students.stream().filter(a -> a.getHeight() > 170).collect(Collectors.toSet());
        System.out.println(students2);

        // 需求5：请找出身高超过170的学生对象，并把学生对象的名字和身高，存入到一个Map集合返回。
        Map<String, Double> map =
                students.stream().filter(a -> a.getHeight() > 170)
                        .distinct().collect(Collectors.toMap(a -> a.getName(), a -> a.getHeight()));
        System.out.println(map);

        // Object[] arr = students.stream().filter(a -> a.getHeight() > 170).toArray();
        Student[] arr = students.stream().filter(a -> a.getHeight() > 170).toArray(len -> new Student[len]);
        System.out.println(Arrays.toString(arr));
    }
4. 实战案例：统计投票
java 复制代码 
List<String> votes = Arrays.asList("A", "B", "A", "C", "B", "A");

// 传统方式
Map<String, Integer> result = new HashMap<>();
for (String vote : votes) {
    result.put(vote, result.getOrDefault(vote, 0) + 1);
}

// Stream方式
Map<String, Long> streamResult = votes.stream()
    .collect(Collectors.groupingBy(v -> v, Collectors.counting()));

五、综合应用：斗地主案例

java 复制代码 
public class PokerGame {
    public static void main(String[] args) {
        // 1. 准备牌
        List<String> colors = List.of("♠", "♥", "♣", "♦");
        List<String> numbers = List.of("3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2");
        
        List<String> poker = new ArrayList<>();
        for (String color : colors) {
            for (String number : numbers) {
                poker.add(color + number);
            }
        }
        poker.add("大王");
        poker.add("小王");

        // 2. 洗牌
        Collections.shuffle(poker);

        // 3. 发牌
        List<String> player1 = new ArrayList<>();
        List<String> player2 = new ArrayList<>();
        List<String> player3 = new ArrayList<>();
        List<String> holeCards = new ArrayList<>();
        
        for (int i = 0; i < poker.size(); i++) {
            String card = poker.get(i);
            if (i < 51) {
                switch (i % 3) {
                    case 0: player1.add(card); break;
                    case 1: player2.add(card); break;
                    case 2: player3.add(card); break;
                }
            } else {
                holeCards.add(card);
            }
        }

        // 4. 看牌
        System.out.println("玩家1: " + player1);
        System.out.println("玩家2: " + player2);
        System.out.println("玩家3: " + player3);
        System.out.println("底牌: " + holeCards);
    }
}

关键技术点：

  1. 使用Collections.shuffle()实现高效洗牌
  2. 利用取模运算实现轮询发牌
  3. 集合分割处理底牌逻辑
  4. 嵌套循环构建扑克牌组合

六、开发经验总结

  1. Map选择原则：

    • 需要快速访问 → HashMap
    • 需要保持插入顺序 → LinkedHashMap
    • 需要自动排序 → TreeMap

  2. Stream使用场景：

    • 数据过滤：filter()
    • 集合转换：map()
    • 统计数据：collect(Collectors.summarizingInt())
    • 并行处理：parallelStream()

  3. 性能注意事项：

    • 大数据集避免多次流操作（可合并操作）
    • 频繁查询的场景慎用TreeMap（O(log n)复杂度）
    • HashMap初始容量设置：new HashMap<>(expectedSize / 0.75f + 1)

  4. 最佳实践：

    java 复制代码 
    // 优雅的Map遍历
map.entrySet().stream()
   .filter(entry -> entry.getValue() > 100)
   .forEach(entry -> process(entry.getKey(), entry.getValue()));

// 安全的空集合处理
List<String> result = Optional.ofNullable(someList)
     .orElseGet(Collections::emptyList)
     .stream()
     .filter(Objects::nonNull)
     .collect(Collectors.toList());

掌握Map集合和Stream流能显著提升Java开发效率，特别是在数据处理密集型应用中。合理选择集合类型+流式处理，可使代码更简洁、可读性更强、更易维护。

相关推荐
Dxy12393102161 小时前
Python PDFplumber详解：从入门到精通的PDF处理指南
开发语言·python·pdf
Dcs1 小时前
用不到 1000 行 Go 实现 BaaS，Pennybase 是怎么做到的？
java
EutoCool2 小时前
Qt：布局管理器Layout
开发语言·c++·windows·嵌入式硬件·qt·前端框架
Cyanto2 小时前
Spring注解IoC与JUnit整合实战
java·开发语言·spring·mybatis
qq_433888932 小时前
Junit多线程的坑
java·spring·junit
gadiaola3 小时前
【SSM面试篇】Spring、SpringMVC、SpringBoot、Mybatis高频八股汇总
java·spring boot·spring·面试·mybatis
写不出来就跑路3 小时前
WebClient与HTTPInterface远程调用对比
java·开发语言·后端·spring·springboot
Cyanto3 小时前
深入MyBatis：CRUD操作与高级查询实战
java·数据库·mybatis
悠哉清闲3 小时前
C++ MediaCodec H264解码
开发语言·c++
张人玉3 小时前
c#中Random类、DateTime类、String类
开发语言·c#
热门推荐
01绿色建筑新态势：楼宇自控助力能效提升，推动成本优化新路径02集群聊天服务器---MySQL数据库的建立03KGG转MP3工具|非KGM文件|解密音频04Java类变量（静态变量）05使用Ruby接入实时行情API教程06Coze扣子平台完整体验和实践（附国内和国际版对比）07基于uni-app的书法学习管理小程序的设计与实现08【无标题】09扣子（coze）实战|我用扣子搭建了一个自动分析小红薯笔记内容的AI应用|详细步骤拆解10RestTemplate原理分析