Java流对象stream的map方法详解

jack.yang

发布于 2025-04-05 17:17:01

2K0

Java 流对象 Stream 的 map 方法是 Stream API 中一个非常核心且强大的功能，它允许对流中的每个元素应用一个函数，将其转换为另一种类型的元素。下面我将从定义、用途、应用范围以及详细示例等方面对 map 方法进行详解。

定义

map 方法是 Stream 接口中的一个中间操作，它接受一个 Function 接口作为参数。这个 Function 接口定义了如何将流中的元素映射为另一个元素。map 方法返回一个新的 Stream，其中包含由原始流中的元素经过函数转换后的结果。

用途

map 方法的主要用途是对流中的元素进行转换或映射。这种转换可以是类型转换、数据提取、逻辑处理等。通过 map 方法，可以轻松地实现复杂的数据处理逻辑，同时保持代码的简洁和可读性。

应用范围

map 方法适用于任何类型的 Stream，无论是基于集合的 Stream、数组的 Stream 还是其他数据源生成的 Stream。它广泛应用于数据处理、集合操作、对象转换等场景。

详细示例

以下是一些详细的示例，展示了如何使用 map 方法进行不同类型的数据转换和处理。

示例 1：字符串长度转换

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class StreamMapExample1 {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
        // 使用 map 将字符串列表转换为对应的长度列表
        List<Integer> lengths = names.stream()
                                     .map(String::length)
                                     .collect(Collectors.toList());
        System.out.println("字符串长度列表: " + lengths);
    }
}

输出结果：

字符串长度列表: [5, 3, 7, 5]

在这个示例中，map 方法接受一个方法引用 String::length，它将每个字符串映射为其长度。

示例 2：数字加倍

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class StreamMapExample2 {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        // 使用 map 将每个数字加倍
        List<Integer> doubledNumbers = numbers.stream()
                                             .map(n -> n * 2)
                                             .collect(Collectors.toList());
        System.out.println("加倍后的数字列表: " + doubledNumbers);
    }
}

输出结果：

加倍后的数字列表: [2, 4, 6, 8, 10]

在这个示例中，map 方法接受一个 Lambda 表达式 n -> n * 2，它将每个数字加倍。

示例 3：对象属性提取

假设有一个 Person 类，包含 name 和 age 属性。

class Person {
    private String name;
    private int age;

    // 构造函数、getter 和 setter 方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

现在，我们有一个 Person 对象的列表，想要提取所有 Person 对象的 name 属性。

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class StreamMapExample3 {
    public static void main(String[] args) {
        List<Person> personList = Arrays.asList(
            new Person("Alice", 30),
            new Person("Bob", 25),
            new Person("Charlie", 35)
        );
        // 使用 map 提取每个 Person 对象的 name 属性
        List<String> names = personList.stream()
                                       .map(Person::getName)
                                       .collect(Collectors.toList());
        System.out.println("Person 对象的 name 属性列表: " + names);
    }
}

输出结果：

Person 对象的 name 属性列表: [Alice, Bob, Charlie]

在这个示例中，map 方法接受一个方法引用 Person::getName，它提取每个 Person 对象的 name 属性。

示例 4：复杂对象转换

假设有一个 Order 类，包含 orderId 和 items 属性，其中 items 是一个包含 OrderItem 对象的列表。现在，我们想要将 Order 对象列表转换为一个包含每个 OrderItem 的 productId 和 quantity 的新列表。

class Order {
    private String orderId;
    private List<OrderItem> items;

    // 构造函数、getter 和 setter 方法
    // ...
}

class OrderItem {
    private String productId;
    private int quantity;

    // 构造函数、getter 和 setter 方法
    // ...
}

接下来，我们初始化几个 OrderItem 实例，并用这些实例构建几个 Order 对象：

// 创建 OrderItem 实例
OrderItem item1 = new OrderItem("P001", 5);
OrderItem item2 = new OrderItem("P002", 3);
OrderItem item3 = new OrderItem("P003", 8);

// 创建 Order 实例
List<OrderItem> orderItems1 = Arrays.asList(item1, item2);
List<OrderItem> orderItems2 = Arrays.asList(item3);
Order order1 = new Order("O001", orderItems1);
Order order2 = new Order("O002", orderItems2);

// 将 Order 实例放入列表中
List<Order> orders = Arrays.asList(order1, order2);

现在，我们已经有了两个订单，每个订单包含不同数量的商品项。下面我们将展示如何使用 Stream API 来转换这些数据结构，生成一个新的列表，该列表中的每一项都是一个 Map<String, Integer>，代表了商品ID和数量的键值对：

import java.util.*;
import java.util.stream.*;

public class Main {
    public static void main(String[] args) {
        // 假设 orders 已经按照上述方式初始化

        // 使用 Stream API 转换数据，java 9及以上
        List<Map<String, Object>> orderItemDetails = orders.stream()
            .flatMap(order -> order.getItems().stream()) // 展平成单个 OrderItem 流
            .map(item -> Map.of( // 创建不可变映射
                "productId", item.getProductId(),
                "quantity", item.getQuantity()
            ))
            .collect(Collectors.toList());

     //Java 8以内
      List<Map<String, Integer>> orderItemDetails = orders.stream()
    .flatMap(order -> order.getItems().stream() // 将每个 Order 转换为其 items 流
        .map(item -> new HashMap<String, Integer>() {{
            put("productId", item.getProductId()); // 插入 productId
            put("quantity", item.getQuantity());   // 插入 quantity
        }})) // 创建包含 productId 和 quantity 的 Map
    .collect(Collectors.toList()); // 收集所有 Map 到 List 中
       

        // 输出结果
        orderItemDetails.forEach(System.out::println);
    }
}

在这个示例中，map 方法与 flatMap 结合使用，将 Order 对象列表转换为一个包含每个 OrderItem 详细信息（productId 和 quantity）的新列表。

这里的关键点在于 flatMap 的使用。flatMap 接收一个函数作为参数，该函数将流中的每个元素转换为另一个流，然后将这些流合并为一个新的流。这与 map 方法不同，map 方法只是将流中的每个元素映射到一个新的元素，而不会改变流的结构。

在这个例子中，首先通过 orders.stream() 创建了一个从 Order 对象列表开始的流。接着，对于每个 Order 对象，我们调用 order.getItems().stream() 来创建一个由该订单的所有 OrderItem 组成的新流。然后，对于每个 OrderItem，我们创建了一个新的 HashMap<String, Integer> 并向其中添加了 productId 和 quantity 键值对。最后，所有的这些 Map 被收集到了一个列表中。

值得注意的是，在这个例子中，匿名内部类（即双括号初始化器）被用来快速创建并填充 HashMap 实例。这种方法简洁但并不总是推荐用于生产环境，因为它可能会导致内存泄漏的问题。更推荐的做法是显式地创建 Map 实例，并使用 put 方法来添加键值对，或者使用 Java 9 引入的 Map.ofEntries 方法等更为现代的方式。

此外，如果需要进一步优化或简化此代码，可以考虑使用记录（record），这是自 Java 14 以来引入的一个特性，允许定义不可变的数据载体类。例如，可以定义一个简单的记录来代替 Map<String, Integer>，从而提高类型安全性并使代码更加清晰。