使用Java Stream groupingBy时添加元素的方法

本文旨在讲解在使用Java Stream的groupingBy方法时，如何根据条件过滤和转换元素，并避免副作用。我们将探讨使用filtering collector在分组后过滤元素，以及filter操作在分组前过滤元素的区别，并提供示例代码进行说明。

在使用Java Stream进行数据处理时，groupingBy方法是一个强大的工具，用于将集合中的元素按照某种规则进行分组。然而，在分组的过程中，我们可能需要根据特定条件过滤或转换元素。本文将介绍几种实现这一目标的方法，并探讨它们之间的差异。

使用filtering Collector进行分组后过滤

Java 9 引入了 Collectors.filtering() 方法，它允许我们在 groupingBy 的 mapping 阶段之后，对每个分组的结果进行过滤。filtering() 接受一个 Predicate 作为参数，只有满足该 Predicate 的元素才会被保留在最终的结果中。

以下是一个示例：

import java.util.List;
import java
.util.Map;
import java.util.stream.Collectors;
import java.util.ArrayList;
import java.util.Objects;
import java.util.Set;
import java.util.HashSet;

enum IOType {
    NONE, TYPE1, TYPE2
}

class User {
    private String stringSeq;
    private Set ioTypes;

    public User(String stringSeq) {
        this.stringSeq = stringSeq;
    }

    public String getStringSeq() {
        return stringSeq;
    }

    public Set getIoTypes() {
        return ioTypes;
    }

    public void setIoTypes(Set ioTypes) {
        this.ioTypes = ioTypes;
    }

    public void addIoType(IOType ioType) {
        if (ioTypes == null) {
            ioTypes = new HashSet<>();
        }
        this.ioTypes.add(ioType);
    }
}

public class GroupingByExample {

    private static final String DELIMITER = "-";
    private static final int MENU_IDX = 0;
    private static final int GROUP_IDX = 1;
    private static final int IO_TYPE_IDX = 2;

    public static void main(String[] args) {
        List userList = new ArrayList<>();
        userList.add(new User("menu1-group1-TYPE1"));
        userList.add(new User("menu1-group1-TYPE2"));
        userList.add(new User("menu2-group2-TYPE1"));
        userList.add(new User("menu2-group2-TYPE2"));
        userList.add(new User("menu3-group3-NONE"));

        Map> groupedUsers = userList.stream()
                .collect(Collectors.groupingBy(
                        e -> {
                            String[] arr = e.getStringSeq().split(DELIMITER);
                            return String.join(DELIMITER, arr[MENU_IDX], arr[GROUP_IDX]);
                        },
                        Collectors.filtering(
                                e -> {
                                    String[] arr = e.getStringSeq().split(DELIMITER);
                                    return !arr[IO_TYPE_IDX].equals("NONE");
                                },
                                Collectors.toList()
                        )
                ));

        System.out.println(groupedUsers);
    }
}

在这个例子中，我们首先使用 groupingBy 根据 menu 和 group 的组合对 User 对象进行分组。然后，我们使用 filtering collector 过滤掉 IOType 为 NONE 的 User 对象。

注意: 如果某个 Key 对应的所有元素都被过滤掉了，那么该 Key 仍然会存在于结果 Map 中，但其 Value 将是一个空列表。

使用filter操作进行分组前过滤

另一种方法是在 groupingBy 之前使用 filter 操作。这种方法会在分组之前过滤掉不符合条件的元素，从而避免了在分组之后进行额外的过滤。

以下是使用 filter 操作的示例：

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.ArrayList;
import java.util.Objects;
import java.util.Set;
import java.util.HashSet;

enum IOType {
    NONE, TYPE1, TYPE2
}

class User {
    private String stringSeq;
    private Set ioTypes;

    public User(String stringSeq) {
        this.stringSeq = stringSeq;
    }

    public String getStringSeq() {
        return stringSeq;
    }

    public Set getIoTypes() {
        return ioTypes;
    }

    public void setIoTypes(Set ioTypes) {
        this.ioTypes = ioTypes;
    }

    public void addIoType(IOType ioType) {
        if (ioTypes == null) {
            ioTypes = new HashSet<>();
        }
        this.ioTypes.add(ioType);
    }
}

public class GroupingByExample {

    private static final String DELIMITER = "-";
    private static final int MENU_IDX = 0;
    private static final int GROUP_IDX = 1;
    private static final int IO_TYPE_IDX = 2;

    public static void main(String[] args) {
        List userList = new ArrayList<>();
        userList.add(new User("menu1-group1-TYPE1"));
        userList.add(new User("menu1-group1-TYPE2"));
        userList.add(new User("menu2-group2-TYPE1"));
        userList.add(new User("menu2-group2-TYPE2"));
        userList.add(new User("menu3-group3-NONE"));

        Map> groupedUsers = userList.stream()
                .filter(e -> {
                    String[] arr = e.getStringSeq().split(DELIMITER);
                    return !arr[IO_TYPE_IDX].equals("NONE");
                })
                .collect(Collectors.groupingBy(
                        e -> {
                            String[] arr = e.getStringSeq().split(DELIMITER);
                            return String.join(DELIMITER, arr[MENU_IDX], arr[GROUP_IDX]);
                        }
                ));

        System.out.println(groupedUsers);
    }
}

在这个例子中，我们首先使用 filter 操作过滤掉 IOType 为 NONE 的 User 对象。然后，我们使用 groupingBy 根据 menu 和 group 的组合对剩余的 User 对象进行分组。

注意: 如果某个 Key 对应的所有元素在 filter 操作中都被过滤掉了，那么该 Key 将不会存在于结果 Map 中。

filtering vs filter: 选择哪种方法?

filtering 和 filter 都可以用于在 groupingBy 中过滤元素，但它们之间存在一些关键的区别：

• 执行顺序: filter 在 groupingBy 之前执行，而 filtering 在 groupingBy 之后执行。
• 结果Map的内容: 如果某个 Key 对应的所有元素都被过滤掉了，filter 会导致该 Key 不存在于结果 Map 中，而 filtering 会导致该 Key 存在于结果 Map 中，但其 Value 是一个空列表。

选择哪种方法取决于你的具体需求。如果需要在分组之前就排除某些元素，并且不希望这些元素影响最终的结果 Map，那么 filter 是一个更好的选择。如果需要在分组之后根据分组的结果进行过滤，或者需要保留所有 Key，即使某些 Key 对应的所有元素都被过滤掉了，那么 filtering 是一个更好的选择。

避免副作用

在stream操作中，应该尽量避免副作用。副作用指的是函数除了返回值之外，还修改了函数外部的状态。在stream操作中使用副作用可能会导致意想不到的结果，并且会使代码难以理解和维护。

在原始问题中，尝试在 mapping 函数中修改 User 对象的 ioTypes 属性就是一个副作用。为了避免副作用，应该创建一个新的 User 对象，并将 ioTypes 属性设置为期望的值。

总结

本文介绍了在使用Java Stream的groupingBy方法时，如何根据条件过滤和转换元素。我们探讨了使用filtering collector在分组后过滤元素，以及filter操作在分组前过滤元素的区别，并提供了示例代码进行说明。此外，我们还强调了避免副作用的重要性，并提供了一些建议。通过理解这些概念，你可以更有效地使用Java Stream进行数据处理。