java - 使用 List java 流时对 Set 对象进行嵌套过滤

Question

需求是根据嵌套的Set对象过滤List。我已经尝试过anyMatch，但似乎它对我不起作用，理想情况下它应该返回 List，它对嵌套 Set 进行过滤。

假设我有契约(Contract)列表 契约(Contract) 1 、契约(Contract) 2。

Contract1 has Set<Activity> = {"START","STOP","WAIT"}

Contract2 has Set<Activity> = {"START", "STOP"}

因此，在这种情况下，最终输出将根据 Activity 类型“START”过滤列表，它应该返回契约(Contract) 1 仅具有 START Activity 的列表，并且与契约(Contract) 2 相同。

**class Contract

public String name;
public Set<Activity> activities;

class Activity

private ActivityType activityType; //enum**



// method for filter list based on the activity type

List<Contract> filterOnActivityList = contractList.stream().filter(contract -> contract.getActivities().stream().anyMatch(activity -> activity.getActivityType().equals("START")))).collect(toList());

Answer 1

据我了解您的问题，您有一个 List Contract 对象。每个 Contract 对象都包含一个 Set Activity 对象。 Activity 对象具有其 ActivityType(其中 ActivityType 是一个 enum)。您想要迭代 List 中的每个 Contract 并检查其 Activity 的 Set 是否包含 Activity 的 ActivityType 为 START，并且您想要提取该 Activity 并收集所有提取的 Activity对象放入另一个单独的 List 中。

这是代码。它使用 Java 9 中引入的方法。(请注意，我猜测并填补了您在问题中发布的代码中的许多空白，例如类 Activity 和类 Contract 和 ActivityType 枚举)。代码后面有说明。

import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

public class Contract {
    private Set<Activity> activities;

    public Contract() {
        activities = new HashSet<>();
    }

    public Set<Activity> getActivities() {
        return activities;
    }

    public void setActivities(Set<Activity> activities) {
        this.activities = activities;
    }

    public static void main(String[] args) {
        Activity a0 = new Activity(ActivityType.OTHER);
        Activity a1 = new Activity(ActivityType.START);
        Activity a2 = new Activity(ActivityType.THAT);
        Contract c0 = new Contract();
        c0.setActivities(Set.of(a0, a1, a2));
        Activity a3 = new Activity(ActivityType.STOP);
        Activity a4 = new Activity(ActivityType.THAT);
        Activity a5 = new Activity(ActivityType.THIS);
        Activity a6 = new Activity(ActivityType.OTHER);
        Contract c1 = new Contract();
        c1.setActivities(Set.of(a3, a4, a5, a6));
        Activity a7 = new Activity(ActivityType.STOP);
        Activity a8 = new Activity(ActivityType.START);
        Contract c2 = new Contract();
        c2.setActivities(Set.of(a7, a8));
        List<Contract> contracts = List.of(c0, c1, c2);
        List<Activity> starts = contracts.stream()
                                         .flatMap(c -> c.getActivities().stream())
                                         .filter(a -> a.getActivityType().equals(ActivityType.START))
                                         .collect(Collectors.toList());
        System.out.println(starts);
    }
}

enum ActivityType {
    START, STOP, THIS, THAT, OTHER;
}

class Activity {
    private ActivityType activityType;

    public Activity(ActivityType type) {
        activityType = type;
    }

    public ActivityType getActivityType() {
        return activityType;
    }

    public String toString() {
        return activityType.name();
    }
}

在方法 main() 中(在上面的代码中)，我创建了一个包含三个 Contract 对象的 List，其中每个对象包含不同的 Activity 对象集。请记住，Set 不包含重复项。

“流”操作获取每个Contract 的activities 并创建Activity 的Stream(此这是 flatMap() 方法的作用)。换句话说，方法 flatMap() 返回 Stream Activity 对象。该流经过过滤，只有 ActivityType 为 START 的 Activity 通过过滤器。最后，通过过滤器的每个 Activity 都被收集到一个新的 List 中，该列表仅包含其 ActivityType 的 Activity 对象。是开始。

运行上述代码的输出是

[START, START]

因为只创建了两个这样的对象。

(现在我猜你可能会写这样的评论:这根本不是我问的:-)