如何从 Java 8 Streams 中的 forEach 循环中获取列表输出

Question

我有两个不同的相同对象列表，但属性不同，并且在这些对象中有一个共同的标识符。我想遍历第一个列表并从第二个列表（具有公共属性）中获取相应的对象，然后将这些对象包装起来，最后使用 Java Streams 将该对象添加到列表中。

这是我举的例子。

private class Person {
        private String name;
        private boolean isSenior;

        private Person(String name, boolean isSenior) {
            this.name = name;
            this.isSenior = isSenior;
        }

        public String getName() {
            return name;
        }

        public boolean isSenior() {
            return isSenior;
        }

        @Override
        public String toString() {
            return name + ": " + isSenior;
        }
    }

    private class PersonWrapper {
        private Person jrPerson;
        private Person srPerson;

        private PersonWrapper(Person jrPerson, Person srPerson) {
            this.jrPerson = jrPerson;
            this.srPerson = srPerson;
        }

        public Person getJrPerson() {
            return jrPerson;
        }

        public Person getSrPerson() {
            return srPerson;
        }

        @Override
        public String toString() {
            return jrPerson.toString() + "-" + srPerson.toString();
        }
    }

现在，在主类中，我将创建两个这样的列表实例

List<Person> jrPersons = new ArrayList<>();
List<Person> srPersons = new ArrayList<>();

并按以下方式添加对象

jrList.add(new Person("John", false));
jrList.add(new Person("Paul", false));
jrList.add(new Person("Mike", false));

seniorList.add(new Person("John", true));
seniorList.add(new Person("Paul", true));
seniorList.add(new Person("Mike", true));

现在，我想遍历 jrList 并在 srList 中找到对应的 Person 对象（同名）。然后我会将这些对象包装为 PersonWrapper 并将该对象包装到一个列表中。

到目前为止，这就是我一直在做的事情

List<PersonWrapper> wrapperList = new ArrayList<>();

jrList.forEach(jr -> seniorList.stream().filter(sr -> jr.getName().equals(sr.getName())).map(sr -> new PersonWrapper(jr, sr)).collect(Collectors.toList()));

现在，我想知道如何将Collectors.toList() 替换为wrapperList，或者如何将Collectors.toList() 的输出添加到wrapperList。

请帮助我实现这一目标。

Answer 1

不要使用forEach，而是从头开始使用流：

List<PersonWrapper> wrapperList = jrList.stream()
    .flatMap(jr -> seniorList.stream()
         .filter(sr -> jr.getName().equals(sr.getName()))
         .map(sr -> new PersonWrapper(jr, sr))
    )
    .collect(Collectors.toList());

通过使用flatMap，您可以展平一个流 (Stream<Stream<PersonWrapper>>) 到单个流 (Stream<PersonWrapper>)

如果您不能自己实例化wrapperList 或确实需要附加到它。您可以将上面的 sn-p 更改为以下内容：

List<PersonWrapper> wrapperList = new ArrayList<>();

jrList.stream()
    .flatMap(jr -> seniorList.stream()
         .filter(sr -> jr.getName().equals(sr.getName()))
         .map(sr -> new PersonWrapper(jr, sr))
    )
    .forEach(wrapperList::add);

Answer 2

虽然Lino's 的答案肯定是正确的。我会争辩说，如果jrList 中的给定人员对象最多只能在seniorList 中有一个对应的匹配项，换句话说，如果它是1-1 关系，那么您可以改进Lino 给出的解决方案找到第一个匹配如下：

List<PersonWrapper> resultSet = jrList.stream()
                .map(p -> seniorList.stream()
                        .filter(sr -> p.getName().equals(sr.getName()))
                        .findFirst()
                        .map(q -> new PersonWrapper(p, q))
                        .get())
                .collect(Collectors.toList());

或者如果不能保证jrList 中的每个人在seniorList 中都有对应的匹配项，则将上述查询更改为：

List<PersonWrapper> resultSet = jrList.stream()
                .map(p -> seniorList.stream()
                        .filter(sr -> p.getName().equals(sr.getName()))
                        .findFirst()
                        .map(q -> new PersonWrapper(p, q))
                        .orElse(null))
                .filter(Objects::nonNull)
                .collect(Collectors.toList());

不同之处在于，现在不是在findFirst() 的结果上调用get()，而是提供orElse 的默认值，以防findFirst 找不到相应的值，然后我们filter null 值在后续的中间操作中退出，因为它们不需要。

Answer 3

用下面的代码替换你的循环逻辑。

 jrList.forEach(jr -> seniorList.stream().filter(sr -> jr.getName().equals(sr.getName()))
                    .map(sr -> wrapperList.add(new PersonWrapper(jr, sr))).collect(Collectors.toList()));