Lambda 收集在消费者方法中创建的元素

Question

我正在从丑陋的嵌套 for 循环转变为在 java 中设计精美的 lambda 表达式。

这是我的实际代码

for (String foo : foos) {
    for (Bar bar : bars) {    
        if (bar.getFoo().equals(foo)) {
            FooBar fooBar = new FooBar();                           
            fooBar.setBar(bar);
            listOfFooBar.add(fooBar);
            break;
        }
    }
}

我的实际 lambda 代码替换上面的代码

foos.forEach(i -> bars.stream().filter(p -> p.getFoo().equals(i)).findFirst().ifPresent(p -> {
        FooBar s = new FooBar();
        fooBar.setBar(bar);
        listOfFooBar.add(fooBar);
    }));

我的问题是，有没有办法用某种 collect() 方法填充 listOfFooBar？

类似listOfFooBar = foos.forEach(.....).collect(Collectors.toList());

一个事实是，bars 将始终包含每个 foo，foos 基本上是 bars 的一小部分。

如果有更好的方法（在性能或优雅方面）来做那个 lambda，请分享。

Answer 1

由于每个 Foo 只有一个 Bar，您可以先创建一个将 Foos 链接到 Bars 的地图：

Map<String, Bar> barsByFoo = bars.stream().collect(toMap(Bar::getFoo, b -> b));

如果你的 bar 比 foos 多很多，你可以过滤：

Map<String, Bar> barsByFoo = bars.stream()
                                 .filter(b -> foos.contains(b.getFoo()))
                                 .collect(toMap(Bar::getFoo, b -> b));

然后可以编写嵌套的 for 循环：

List<FooBar> listOfFooBar = foos.stream()
        .map(barsByFoo::get)
        .filter(Objects::nonNull)
        .map(FooBar::new)
        .collect(toList());

这假设有一个FooBar(Bar) 构造函数。

或者您可以从另一边解决问题并使用（我认为）等效算法（在这种情况下，您可能会从使用Set<Foo> 中受益）：

List<FooBar> listOfFooBar = bars.stream()
        .filter(bar -> foos.contains(bar.getFoo()))
        .map(FooBar::new)
        .collect(toList());

无论哪种方式，从初始循环中退出通常会有所帮助，因为不同的算法/方法通常有利于干净的 lambda 解决方案。

Answer 2

如果你想走完整个九码：

List<FooBar> listOfFooBar = foos.stream()
  .flatMap(foo -> bars.stream().filter(bar-> bar.getFoo().equals(foo)).findFirst()
                    .map(Stream::of).orElse(Stream.empty()))
  .map(bar -> {
                FooBar fooBar = new FooBar();
                fooBar.setBar(bar);
                return fooBar;
              })
  .collect(Collectors.toList());

如果您有一个接受Bar 的FooBar 构造函数，那么您可以节省一些行并编写

.map(FooBar::new)

你可以在 Java 9 中编写 FWIW

.findFirst().stream()

假设有一个合适的构造函数，那么它将缩短为

List<FooBar> listOfFooBar = foos.stream()
  .flatMap(foo -> bars.stream().filter(bar-> bar.getFoo().equals(foo)).findFirst().stream()))
  .map(FooBar::new)
  .collect(Collectors.toList());

编辑： 使用@Misha 的建议，您可以进一步缩短它：

List<FooBar> listOfFooBar = foos.stream()
  .flatMap(foo -> bars.stream().filter(bar-> bar.getFoo().equals(foo)).limit(1)))
  .map(FooBar::new)
  .collect(Collectors.toList());

Answer 3

如果FooBar 有一个接受Bar 作为参数的构造函数：

public class FooBar {

    public FooBar(Bar bar) {
        // do something with bar, assign it, etc
    }
}

那么，你可以这样做：

List<FooBar> fooBars = foos.stream()
    .map(foo -> bars.stream()
        .filter(bar -> bar.getFoo().equals(foo))
        .findFirst()
        .map(FooBar::new))
    .filter(Optional::isPresent)
    .map(Optional::get)
    .collect(Collectors.toList());

这会流式传输您的foos，并且对于每个foo，它会流式传输您的bars，直到找到与当前foo 匹配的第一个。如果实际找到foo，则从内部流的当前bar 创建一个新的FooBar。这给我们留下了Optional<FooBar> 的流，然后对其进行过滤以仅保留非空选项。然后，将可选项转换为它们包含的值（即上一步创建的FooBars），最后将这些FooBars 收集到List<FooBar>。

编辑： 那是我的第一次尝试。使用@zeroflagL 的方法要好得多：

List<FooBar> fooBars = foos.stream()
    .flatMap(foo -> bars.stream()
        .filter(bar -> bar.getFoo().equals(foo))
        .findFirst()
        .map(Stream::of).orElse(Stream.empty()))
    .map(FooBar::new)
    .collect(Collectors.toList());