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

MarcG:

我可以添加流或其他元素,如下所示:

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);

我的问题是:

1)是否有充分的理由为什么它concat是静态的?还是我缺少一些等效的实例方法?

2)无论如何,有没有更好的方法?

nosid:

如果Stream.concatStream.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);

所需语法和上面语法之间的唯一区别是,您必须collect(concat(...))替换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两种操作都会对程序的行为产生重大影响。但是,如果可读性性能更重要,它可能仍然是非常有用的方法。

本文收集自互联网,转载请注明来源。

如有侵权,请联系 [email protected] 删除。

编辑于
0

我来说两句

0 条评论
登录 后参与评论

相关文章

如何验证一个Java 8个流中有两个特定的元素呢?

Java 8流混合两个元素

两个流调用Ajax方法,一个在最后需要额外处理

有没有办法在一个Java8流中读取两个或更多文件?

合并两个流Java 8

Java的8两个列表流

Java 8嵌套流:在最后一个流中返回一个值

每当一个流发出时从两个流中获取值

Java流中的foreach LAMBDA使用一个元素

Java8:流相同的流中的映射的两个属性

Java 8 - 在同一流代码中更新两个属性

Java8流-比较两个列表的对象值并将值添加到第一个列表的子对象?

如何将两个 java8 流操作 - 一个终端和一个惰性 - 合并为一个操作?

Java-在arraylist中的两个元素之间添加一个元素

如何在Java8流中将两个String列表合并为一个列表而不重复

Java的8流 - 如何合并从具有相同的字段列表中的元素,以一个元素和总结

当一个元素发生异常时,如何处理 Java 8 流列表中的剩余元素?

将两个流合并为一个

Java8流:一个条件之后收集元素满足

当一个Java 8个流认为是消费?

JAVA将两个流处理成一个单一的映射

Java流:流的第一个元素减去流的其余部分的总和

jQuery向滚动中的两个元素添加一个类,但具有不同的属性

Java的流压缩两个列表

Java流 - 应用两个过滤器,并收集到两个集合中的一个迭代

将这两个Java流合并为一个

如何交错(合并)两个Java 8流?

重构两个用于公司为Java 8流

Java 8生成两个的倍数的流