map()结合其他的实际使用

map() 是 Java Stream API 中一个非常重要的中间操作，用于将流中的每个元素应用一个函数并返回一个新的流。它的作用是将输入的元素“映射”到一个新的元素上，通常用于转换数据的结构或类型。

1. map() 的基础用法

map() 的基本作用是将流中的每个元素应用某个函数并生成一个新的元素。例如：

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

List<Integer> nameLengths = names.stream()
    .map(String::length)  // 将每个名字映射为其长度
    .collect(Collectors.toList());

System.out.println(nameLengths);  // 输出：[5, 3, 7]

解释：这里我们用 map() 将字符串流转换成其长度的整数流。每个名字（如 “Alice”）经过 String::length 处理后，变成了一个整数。

2. map() 与 filter() 的结合

map() 和 filter() 经常结合使用。filter() 用于筛选元素，而 map() 用于转换筛选后的元素。

示例：筛选并转换整数列表

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

List<Integer> squaredEvens = numbers.stream()
    .filter(n -> n % 2 == 0)  // 筛选偶数
    .map(n -> n * n)          // 将筛选后的偶数映射为它们的平方
    .collect(Collectors.toList());

System.out.println(squaredEvens);  // 输出：[4, 16, 36, 64, 100]

解释：首先通过 filter() 筛选出偶数，然后使用 map() 将偶数转换为它们的平方。最终结果是 [4, 16, 36, 64, 100]。

3. map() 与 reduce() 的结合

map() 可以与 reduce() 结合，实现将数据转换后再进行归约操作。典型应用场景是处理和汇总数据。

示例：计算平方数的总和

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

int sumOfSquares = numbers.stream()
    .map(n -> n * n)       // 将每个数字映射为它的平方
    .reduce(0, Integer::sum);  // 求和

System.out.println(sumOfSquares);  // 输出：55

解释：map() 将每个数字转换为它的平方，然后 reduce() 将这些平方值累加得到总和。最终结果是 1 + 4 + 9 + 16 + 25 = 55。

4. map() 与 flatMap() 的区别

map() 和 flatMap() 的区别在于：map() 是一对一的映射，而 flatMap() 是一对多的映射，通常用于将多个嵌套集合“展开”。

示例：使用 map() 处理嵌套集合

List<List<String>> nestedList = Arrays.asList(
    Arrays.asList("Apple", "Banana"),
    Arrays.asList("Orange", "Grapes")
);

List<String> flatList = nestedList.stream()
    .flatMap(List::stream)  // 将每个列表展平为单个流
    .collect(Collectors.toList());

System.out.println(flatList);  // 输出：[Apple, Banana, Orange, Grapes]

解释：flatMap() 将嵌套的 List 打平，使其成为单个元素的流。map() 不能做到这一点，因为它只进行单一的映射，而不“展开”嵌套结构。

5. map() 与 collect() 的结合

map() 可以结合 collect() 操作，将流中的元素转换并收集到集合中。

示例：将对象的属性值映射并收集

假设我们有一个 Person 对象，想提取每个人的名字并将其收集到一个列表中：

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }
}

List<Person> people = Arrays.asList(
    new Person("Alice", 30),
    new Person("Bob", 25),
    new Person("Charlie", 35)
);

List<String> names = people.stream()
    .map(Person::getName)  // 映射每个 Person 对象为其名字
    .collect(Collectors.toList());

System.out.println(names);  // 输出：[Alice, Bob, Charlie]

解释：map() 将 Person 对象的流映射为名字的流，最终通过 collect() 将结果收集到一个 List 中。

6. map() 与 forEach() 的结合

map() 可以将流中的元素映射为其他类型或对象，forEach() 则可以对每个映射后的元素进行操作。

示例：打印处理后的元素

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

names.stream()
    .map(String::toUpperCase)  // 将名字转换为大写
    .forEach(System.out::println);  // 输出每个名字

// 输出：
// ALICE
// BOB
// CHARLIE

解释：map() 将每个名字转换为大写，然后通过 forEach() 输出结果。

7. map() 与 sorted() 的结合

map() 可以将元素映射为可排序的类型，然后使用 sorted() 对结果进行排序。

示例：对字符串长度进行排序

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

List<String> sortedByLength = names.stream()
    .sorted(Comparator.comparingInt(String::length))  // 按字符串长度排序
    .collect(Collectors.toList());

System.out.println(sortedByLength);  // 输出：[Bob, Alice, Charlie]

解释：sorted() 按照字符串的长度对流进行排序。通过结合 map()，你可以先将对象映射为其某些属性，然后基于这些属性排序。

8. map() 与 groupingBy() 的结合

map() 和 Collectors.groupingBy() 结合使用时，可以先映射元素然后按特定标准分组。

示例：按名称长度分组

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

Map<Integer, List<String>> namesByLength = names.stream()
    .collect(Collectors.groupingBy(String::length));  // 按名字长度分组

System.out.println(namesByLength);
// 输出：{3=[Bob], 5=[Alice, David], 7=[Charlie]}

解释：这里我们按名字的长度将它们分组，通过 groupingBy() 来实现。

9. map() 与 max() 或 min() 的结合

你可以通过 map() 先转换元素，然后用 max() 或 min() 找出最大或最小值。

示例：找出最长的名字

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

Optional<String> longestName = names.stream()
    .max(Comparator.comparingInt(String::length));  // 找出长度最长的名字

longestName.ifPresent(System.out::println);  // 输出：Charlie

解释：max() 基于名字的长度比较并找出最长的名字。

10. 结合实际开发场景的 map() 使用

在实际开发中，map() 通常用于将数据转换成某种需要的结构，或者从对象中提取出关键信息。在结合数据库查询、JSON 解析、REST API 响应处理时，map() 是一个非常有用的工具。

示例：从 API 响应中提取数据

假设我们从 API 得到一个用户对象的列表，想要提取每个用户的 ID：

List<JSONObject> users = apiResponse.getJSONArray("users").toJavaList(JSONObject.class);

List<Integer> userIds = users.stream()
    .map(user -> user.getInteger("id"))  // 提取用户 ID
    .collect(Collectors.toList());

System.out.println(userIds);  // 输出所有用户的 ID 列表

总结

• map() 用于将流中的元素通过一个函数映射到新的元素。
• 可以结合 filter() 筛选数据，reduce() 进行归约，flatMap() 展开嵌套结构，collect() 收集结果。
• 在实际开发中，map() 非常适合用来转换对象