Stream流式编程 练习题

文章目录

• • 一、List相关
  • • [题 1：基础过滤 + 映射](#题 1：基础过滤 + 映射)
    • [题 2：对象 List + 多条件筛选](#题 2：对象 List + 多条件筛选)
    • [题 3：统计类终止操作](#题 3：统计类终止操作)
  • [二、Set 相关 Stream 题（去重 + 聚合）](#二、Set 相关 Stream 题（去重 + 聚合）)
  • • [题 4：Set + 映射](#题 4：Set + 映射)
    • [题 5：Set 转 Map](#题 5：Set 转 Map)
  • [三、Map 相关 Stream 题（高频面试点🔥）](#三、Map 相关 Stream 题（高频面试点🔥）)
  • • [题 6：Map 过滤 + 收集](#题 6：Map 过滤 + 收集)
    • [题 7：Map.Entry 操作](#题 7：Map.Entry 操作)
    • [题 8：Map 聚合统计](#题 8：Map 聚合统计)
  • [四、数组相关 Stream 题（细节陷阱多⚠️）](#四、数组相关 Stream 题（细节陷阱多⚠️）)
  • • [题 9：基本类型数组](#题 9：基本类型数组)
    • [题 10：对象数组](#题 10：对象数组)
  • 五、综合提升题（区分高手🔥）
  • • [题 11：分组 + 统计](#题 11：分组 + 统计)
    • [题 12：flatMap 应用](#题 12：flatMap 应用)
    • [题 13：短路操作](#题 13：短路操作)
  • [六、Stream 特性理解题（必考⚠️）](#六、Stream 特性理解题（必考⚠️）)
  • • [题 14：下面代码会执行几次 `filter`？](#题 14：下面代码会执行几次 filter？)
    • [题 15：Stream 相关判断题（多选）](#题 15：Stream 相关判断题（多选）)

如果小伙伴们还不了解Stream流式编程可以先去看看Stream流式编程讲解

一、List相关

题 1：基础过滤 + 映射

已知：

List<String> names = Arrays.asList("Tom", "Jerry", "Alice", "Bob", "Tom");

要求：

1. 去除重复姓名

2. 过滤掉长度小于 4 的姓名

3. 转成大写

4. 按字母顺序排序

5. 返回 List<String>

答案：

List<String> result = names.stream()
        .distinct()
        .filter(name -> name.length() >= 4)
        .map(String::toUpperCase)
        .sorted()
        .collect(Collectors.toList());

题 2：对象 List + 多条件筛选

已知：

class User {
    private Long id;
    private String name;
    private int age;
    private boolean enabled;
}

List<User> users

要求：

1. 只保留 enabled = true

2. 年龄在 18 ~ 35 之间

3. 按年龄 倒序

4. 返回 用户姓名 List

答案：

List<String> result = users.stream()
        .filter(User::isEnabled)
        .filter(u -> u.getAge() >= 18 && u.getAge() <= 35)
        .sorted(Comparator.comparingInt(User::getAge).reversed())
        .map(User::getName)
        .collect(Collectors.toList());

---

题 3：统计类终止操作

给定：

List<Integer> scores = Arrays.asList(60, 70, 80, 90, 100, 90);

要求使用 Stream：

1. 计算平均分

2. 计算最高分

3. 统计 大于等于 90 分的人数

答案

double avg = scores.stream()
        .mapToInt(Integer::intValue)
        .average()
        .orElse(0);

int max = scores.stream()
        .mapToInt(Integer::intValue)
        .max()
        .orElse(0);

long count = scores.stream()
        .filter(s -> s >= 90)
        .count();

---

二、Set 相关 Stream 题（去重 + 聚合）

题 4：Set + 映射

已知：

Set<String> cities = new HashSet<>(Arrays.asList("beijing", "shanghai", "guangzhou"));

要求：

1. 将首字母大写

2. 按字符串长度排序

3. 返回 List<String>

答案：

List<String> result = cities.stream()
        .map(s -> s.substring(0, 1).toUpperCase() + s.substring(1))
        .sorted(Comparator.comparingInt(String::length))
        .collect(Collectors.toList());

---

题 5：Set 转 Map

已知：

Set<User> users;

要求：

1. 以 id 为 key

2. User 为 value

3. 若出现重复 id，保留 年龄较大的 User

答案：

Map<Long, User> result = users.stream()
        .collect(Collectors.toMap(
                User::getId,
                Function.identity(),
                (u1, u2) -> u1.getAge() >= u2.getAge() ? u1 : u2
        ));

---

三、Map 相关 Stream 题（高频面试点🔥）

题 6：Map 过滤 + 收集

已知：

Map<String, Integer> scoreMap;

要求：

1. 过滤出分数 ≥ 80

2. 按分数 降序排序

3. 返回新的 LinkedHashMap<String, Integer>

答案：

Map<String, Integer> result = scoreMap.entrySet().stream()
        .filter(e -> e.getValue() >= 80)
        .sorted(Map.Entry.<String, Integer>comparingByValue().reversed())
        .collect(Collectors.toMap(
                Map.Entry::getKey,
                Map.Entry::getValue,
                (a, b) -> a,
                LinkedHashMap::new
        ));

---

题 7：Map.Entry 操作

已知：

Map<Long, User> userMap;

要求：

1. 过滤年龄 ≥ 30 的用户

2. 只保留用户名

3. 返回 List<String>

答案：

List<String> result = userMap.values().stream()
        .filter(u -> u.getAge() >= 30)
        .map(User::getName)
        .collect(Collectors.toList());

---

题 8：Map 聚合统计

已知：

Map<String, List<Integer>> classScores;

key = 班级名

value = 分数列表

要求：

👉 计算 每个班级的平均分

返回：

Map<String, Double>

答案：

Map<String, Double> result = classScores.entrySet().stream()
        .collect(Collectors.toMap(
                Map.Entry::getKey,
                e -> e.getValue().stream()
                        .mapToInt(Integer::intValue)
                        .average()
                        .orElse(0)
        ));

---

四、数组相关 Stream 题（细节陷阱多⚠️）

题 9：基本类型数组

已知：

int[] nums = {1, 2, 3, 4, 5, 6};

要求：

1. 过滤偶数

2. 每个数平方

3. 求和

⚠️ 要求使用 IntStream

答案：

int sum = Arrays.stream(nums)
        .filter(n -> n % 2 == 0)
        .map(n -> n * n)
        .sum();

---

题 10：对象数组

已知：

User[] userArray;

要求：

1. 过滤年龄 ≥ 18

2. 按年龄升序

3. 转成 List<User>

答案：

List<User> result = Arrays.stream(userArray)
        .filter(u -> u.getAge() >= 18)
        .sorted(Comparator.comparingInt(User::getAge))
        .collect(Collectors.toList());

---

五、综合提升题（区分高手🔥）

题 11：分组 + 统计

已知：

List<User> users;

要求：

👉 按年龄区间分组：

• < 18

• 18 ~ 30

• > 30

返回：

Map<String, List<User>>

答案：

Map<String, List<User>> result = users.stream()
        .collect(Collectors.groupingBy(u -> {
            if (u.getAge() < 18) {
                return "<18";
            } else if (u.getAge() <= 30) {
                return "18~30";
            } else {
                return ">30";
            }
        }));

---

题 12：flatMap 应用

已知：

List<List<String>> data = Arrays.asList( Arrays.asList("a", "b"), Arrays.asList("c", "d"), Arrays.asList("a", "e") );

要求：

1. 扁平化

2. 去重

3. 按字母排序

4. 拼接成一个字符串（如 "abcde"）

答案：

String result = data.stream()
        .flatMap(List::stream)
        .distinct()
        .sorted()
        .collect(Collectors.joining());

---

题 13：短路操作

已知：

List<Integer> nums;

要求：

1. 判断是否 存在任意一个 数字 > 100

2. 判断是否 全部 数字 > 0

3. 找到第一个偶数

答案：

boolean exists = nums.stream().anyMatch(n -> n > 100);

boolean allPositive = nums.stream().allMatch(n -> n > 0);

Optional<Integer> firstEven = nums.stream()
        .filter(n -> n % 2 == 0)
        .findFirst();

---

六、Stream 特性理解题（必考⚠️）

题 14：下面代码会执行几次 filter？

stream
    .filter(x -> {
        System.out.println("filter");
        return x > 10;
    })
    .limit(2)
    .forEach(System.out::println);

---

题 15：Stream 相关判断题（多选）

1. Stream 可以复用

2. 中间操作会立刻执行

3. findFirst 是终止操作

4. peek 会改变流中元素

5. 并行流一定比串行流快

选项	正误	说明
Stream 可以复用	❌	终止操作后流关闭
中间操作会立刻执行	❌	惰性执行
findFirst 是终止操作	✅	会触发执行
peek 会改变流中元素	❌	仅用于调试
并行流一定更快	❌	小数据反而更慢

---