向一个流中添加两个Java8流或一个额外的元素

Question

我可以添加流或额外的元素，像这样：

Stream stream = Stream.concat(stream1, Stream.concat(stream2, Stream.of(element));

我可以边走边添加新的东西，比如：

Stream stream = Stream.concat(
                       Stream.concat(
                              stream1.filter(x -> x!=0), stream2)
                              .filter(x -> x!=1),
                                  Stream.of(element))
                                  .filter(x -> x!=2);

但这很难看，因为concat是静态的。如果concat是一个实例方法，那么上面的示例将更容易阅读：

 Stream stream = stream1.concat(stream2).concat(element);

而且

 Stream stream = stream1
                 .filter(x -> x!=0)
                 .concat(stream2)
                 .filter(x -> x!=1)
                 .concat(element)
                 .filter(x -> x!=2);

2）无论如何，有没有更好的方法？

Answer 1

如果为Stream.concat和Stream.of添加静态导入，第一个示例可以编写如下：

Stream<Foo> stream = concat(stream1, concat(stream2, of(element)));

导入带有泛型名称的静态方法会导致代码变得难以读取和维护（名称空间污染）。因此，最好使用更有意义的名称创建自己的静态方法。但是，为了演示，我将坚持使用这个名称。

public static <T> Stream<T> concat(Stream<? extends T> lhs, Stream<? extends T> rhs) {
    return Stream.concat(lhs, rhs);
}
public static <T> Stream<T> concat(Stream<? extends T> lhs, T rhs) {
    return Stream.concat(lhs, Stream.of(rhs));
}

使用这两个静态方法（可选地与静态导入结合使用），这两个示例可以写成如下：

Stream<Foo> stream = concat(stream1, concat(stream2, element));

Stream<Foo> stream = concat(
                         concat(stream1.filter(x -> x!=0), stream2).filter(x -> x!=1),
                         element)
                     .filter(x -> x!=2);

代码现在大大缩短了。然而，我同意可读性并没有提高。所以我有另一个解决办法。

在很多情况下，收集器可以用来扩展流的功能。在底部有两个收集器的情况下,这两个示例可以写成如下：

Stream<Foo> stream = stream1.collect(concat(stream2)).collect(concat(element));

Stream<Foo> stream = stream1
                     .filter(x -> x!=0)
                     .collect(concat(stream2))
                     .filter(x -> x!=1)
                     .collect(concat(element))
                     .filter(x -> x!=2);

您想要的语法和上面的语法之间的唯一区别是，您必须替换concat（...）使用collect（concat（...））。这两种静态方法可以实现如下（可选地与静态导入结合使用）：

private static <T,A,R,S> Collector<T,?,S> combine(Collector<T,A,R> collector, Function<? super R, ? extends S> function) {
    return Collector.of(
        collector.supplier(),
        collector.accumulator(),
        collector.combiner(),
        collector.finisher().andThen(function));
}
public static <T> Collector<T,?,Stream<T>> concat(Stream<? extends T> other) {
    return combine(Collectors.toList(),
        list -> Stream.concat(list.stream(), other));
}
public static <T> Collector<T,?,Stream<T>> concat(T element) {
    return concat(Stream.of(element));
}

当然，这个解决方案有一个缺点是应该提到的。collect是消耗流的所有元素的最终操作。在此基础上，收集器concat每次在链中使用时都会创建一个中间ArrayList。这两种操作都可能对程序的行为产生重大影响。然而，如果可读性比性能更重要，那么它可能仍然是一种非常有用的方法。