如何正确地将流减少到另一个流

Question

我有字符串流和像

这样的空值

Stream<String> str1 = Stream.of("A","B","C",null,null,"D",null,"E","F",null,"G",null);

我想将它简化为另一个流，其中任何非空字符串序列连接在一起，即喜欢

Stream<String> str2 = Stream.of("ABC", "", "D", "EF","G")

我发现的第一种方法 - 创建收集器，首先将完整的输入流减少为具有所有连接字符串列表的单个对象，然后从中创建新流：

class Acc1 {
  final private List<String> data = new ArrayList<>();
  final private StringBuilder sb = new StringBuilder();

  private void accept(final String s) {
    if (s != null) 
      sb.append(s);
    else {
      data.add(sb.toString());
      sb.setLength(0);
    }
  }

  public static Collector<String,Acc1,Stream<String>> collector() {
    return Collector.of(Acc1::new, Acc1::accept, (a,b)-> a, acc -> acc.data.stream());
  }
}
...
Stream<String> str2 = str.collect(Acc1.collector());

但在这种情况下，在任何使用 str2 之前，即使是 str2.findFirst()，输入流也会被完全处理。它消耗时间和内存的操作以及来自某个生成器的无限流它根本无法工作

另一种方式 - 创建将保持中间状态并在 flatMap() 中使用的外部对象：

class Acc2 {
  final private StringBuilder sb = new StringBuilder();

  Stream<String> accept(final String s) {
    if (s != null) {
      sb.append(s);
      return Stream.empty();
    } else {
      final String result = sb.toString();
      sb.setLength(0);
      return Stream.of(result);
    }
  }
}
...
Acc2 acc = new Acc2();
Stream<String> str2 = str1.flatMap(acc::accept);

在这种情况下，从 str1 将只检索真正通过 str2 访问的元素。

但是使用在流处理之外创建的外部对象对我来说看起来很难看，并且可能会导致一些我现在看不到的副作用。此外，如果 str2 稍后将与 parallelStream() 一起使用，则会导致不可预测的结果。

有没有更正确的流->流减少没有这些缺陷的实现？

Answer 1

归约或其可变变体collect 始终是一个将处理所有项目的操作。您的操作可以通过自定义Spliterator 来实现，例如

public static Stream<String> joinGroups(Stream<String> s) {
    Spliterator<String> sp=s.spliterator();
    return StreamSupport.stream(
        new Spliterators.AbstractSpliterator<String>(sp.estimateSize(), 
        sp.characteristics()&Spliterator.ORDERED | Spliterator.NONNULL) {
            private StringBuilder sb = new StringBuilder();
            private String last;

            public boolean tryAdvance(Consumer<? super String> action) {
                if(!sp.tryAdvance(str -> last=str))
                    return false;
                while(last!=null) {
                    sb.append(last);
                    if(!sp.tryAdvance(str -> last=str)) break;
                }
                action.accept(sb.toString());
                sb=new StringBuilder();
                return true;
            }
        }, false);
}

生成预期的组，您可以使用它进行测试

joinGroups(Stream.of("A","B","C",null,null,"D",null,"E","F",null,"G",null))
    .forEach(System.out::println);

但也有所需的惰性行为，可通过

测试

joinGroups(
    Stream.of("A","B","C",null,null,"D",null,"E","F",null,"G",null)
          .peek(str -> System.out.println("consumed "+str))
).skip(1).filter(s->!s.isEmpty()).findFirst().ifPresent(System.out::println);

---

经过深思熟虑，我想到了这个更有效的变体。仅当至少有两个 Strings 加入时，它才会合并 StringBuilder，否则，它将简单地使用已经存在的唯一 String 实例或文字 "" 字符串作为空组：

public static Stream<String> joinGroups(Stream<String> s) {
    Spliterator<String> sp=s.spliterator();
    return StreamSupport.stream(
        new Spliterators.AbstractSpliterator<String>(sp.estimateSize(), 
        sp.characteristics()&Spliterator.ORDERED | Spliterator.NONNULL) {
            private String next;

            public boolean tryAdvance(Consumer<? super String> action) {
                if(!sp.tryAdvance(str -> next=str))
                    return false;
                String string=next;
                if(string==null) string="";
                else if(sp.tryAdvance(str -> next=str) && next!=null) {
                    StringBuilder sb=new StringBuilder().append(string);
                    do sb.append(next);while(sp.tryAdvance(str -> next=str) && next!=null);
                    string=sb.toString();
                }
                action.accept(string);
                return true;
            }
        }, false);
}

Answer 2

使用标准 Stream API 很难实现这样的场景。在我的免费 StreamEx 库中，我使用允许执行所谓的“部分缩减”的方法扩展了标准 Stream 接口，这正是这里所需要的：

StreamEx<String> str1 = StreamEx.of("A","B","C",null,null,"D",null,"E","F",null,"G",null);
Stream<String> str2 = str1.collapse((a, b) -> a != null,
                          MoreCollectors.filtering(Objects::nonNull, Collectors.joining()));
str2.map(x -> '"'+x+'"').forEach(System.out::println);

输出：

"ABC"
""
"D"
"EF"
"G"

StreamEx.collapse() 方法使用提供的收集器执行流的部分缩减。第一个参数是一个谓词，适用于两个相邻的原始项目，如果它们必须一起归约，则应返回 true。这里我们只要求第一个不为空（(a, b) -> a != null）：这意味着每个组都以null 结尾，新组从这里开始。现在我们需要将组字母连接在一起：这可以通过标准的Collectors.joining()collector 来完成。但是我们还需要过滤掉null。我们可以使用MoreCollectors.filtering 收集器来实现（实际上相同的收集器将在 Java 9 的 Collectors 类中可用）。

这个实现是完全惰性的，对并行处理非常友好。