没有（不必要的）嵌套循环的处理两个相关列表

Question

Book book = ... 
Optional<Author> authorO = authors.stream
                               .filter(author -> author.getId().equals(book.getAuthorId()))
                               .findFirst();

所以我想要这样的东西。你能告诉我怎么做吗？谢谢你。

List<Book> books = ...
List<Author> authors = ...

books
    .stream()
    .??? // stream of pairs? 
    .forEach((book, author) -> {
        processingOne(book, author);

        if (featureFlag2) {
            processingTwo(book, author);
        }

        ...
    });

Answer 1

在开始处理图书列表之前，我建议您创建一个以authorid为键和author为值的映射：

Map<Integer, Author> authorMap = authors.stream()
                                        .collect(Collectors.toMap(Author::getAuthorId,
                                                                  Function.identity()));
                               

然后对图书列表进行流式处理,并将其处理为：

books.stream()   
     .forEach(book -> {
         Author author = authorMap.get(book.getAuthorId());
         processingOne(book, author);

         if (featureFlag2) {
             processingTwo(book, author);
         }

         //...
     });

编辑：做同样事情的不同方式。这种方法利用了有状态lambda。

public Consumer<Book> processor(List<Author> authors, boolean featureFlag2) {
    // use concurrent map if you use parallelStream
    // authorMap is the state. It is created only once for the stream.
    Map<Integer, Author> authorMap 
        = authors.stream()
                 .collect(Collectors.toMap(Author::getAuthorId,
                                           Function.identity()));
    return book -> {
        Author author = authorMap.get(book.getAuthorId());
        processingOne(book, author);
        if (featureFlag2) {
            processingTwo(book, author);
        }
    };
}

books.stream()
     .forEach(processor(authors, featureFlag2));