Java 8中流的笛卡尔积作为流(仅使用流)

Question

我想创建一个方法来创建一个元素流,这些元素是多个给定流的笛卡尔积(由二元运算符在末尾聚合到相同类型).请注意,参数和结果都是流,而不是集合.

例如,对于{A,B}和{X,Y}的两个流,我希望它生成值{AX,AY,BX,BY}的流(简单串联用于聚合字符串).到目前为止,我已经提出了这个代码:

private static <T> Stream<T> cartesian(BinaryOperator<T> aggregator, Stream<T>... streams) {
    Stream<T> result = null;

    for (Stream<T> stream : streams) {
        if (result == null) {
            result = stream;
        } else {
            result = result.flatMap(m -> stream.map(n -> aggregator.apply(m, n)));
        }
    }

    return result;
}

这是我想要的用例:

Stream<String> result = cartesian(
  (a, b) -> a + b, 
  Stream.of("A", "B"), 
  Stream.of("X", "Y")
);

System.out.println(result.collect(Collectors.toList()));

预期结果:AX, AY, BX, BY.

另一个例子:

Stream<String> result = cartesian(
  (a, b) -> a + b, 
  Stream.of("A", "B"), 
  Stream.of("K", "L"), 
  Stream.of("X", "Y")
);

预期结果:AKX, AKY, ALX, ALY, BKX, BKY, BLX, BLY.

但是,如果我运行代码,我会收到此错误:

IllegalStateException:流已经被操作或关闭

消耗的流在哪里？通过flatMap？可以轻松修复吗？

Answer 1

在示例中传递流不会比传递列表更好:

private static <T> Stream<T> cartesian(BinaryOperator<T> aggregator, List<T>... lists) {
    ...
}

并像这样使用它:

Stream<String> result = cartesian(
  (a, b) -> a + b, 
  Arrays.asList("A", "B"), 
  Arrays.asList("K", "L"), 
  Arrays.asList("X", "Y")
);

在这两种情况下,您都可以从varargs创建一个隐式数组并将其用作数据源,因此懒惰是虚构的.您的数据实际存储在数组中.

在大多数情况下,产生的笛卡尔积流比输入长得多,因此实际上没有理由使输入变得懒惰.例如,有五个元素的列表(总共25个),您将得到3125个元素的结果流.因此在存储器中存储25个元素不是很大的问题.实际上,在大多数实际情况中,它们已经存储在存储器中.

为了生成笛卡尔积的流,您需要不断地"回放"所有流(第一个除外).要回放,流应该能够一次又一次地检索原始数据,或者以某种方式缓冲它们(你不喜欢它们)或者从源中再次抓取它们(colleciton,数组,文件,网络,随机数等).并且一次又一次地执行所有中间操作.如果您的源和中间操作很慢,那么延迟解决方案可能比缓冲解决方案慢得多.如果您的源无法再次生成数据(例如,随机数生成器无法生成之前生成的相同数字),则您的解决方案将不正确.

然而,完全懒惰的解决方案是可能的.只是使用不是流,而是流供应商:

private static <T> Stream<T> cartesian(BinaryOperator<T> aggregator,
                                       Supplier<Stream<T>>... streams) {
    return Arrays.stream(streams)
        .reduce((s1, s2) -> 
            () -> s1.get().flatMap(t1 -> s2.get().map(t2 -> aggregator.apply(t1, t2))))
        .orElse(Stream::empty).get();
}

解决方案很有意思,因为我们创建并减少供应商流以获得最终供应商并最终称之为供应商.用法:

Stream<String> result = cartesian(
          (a, b) -> a + b, 
          () -> Stream.of("A", "B"), 
          () -> Stream.of("K", "L"), 
          () -> Stream.of("X", "Y")
        );
result.forEach(System.out::println);