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

Answer 2

stream在第二次迭代中的flatMap操作中使用。因此，每次map结果时都必须创建新流。因此，您必须提前收集stream以在每次迭代中获得新流。

private static <T> Stream<T> cartesian(BiFunction<T, T, T> aggregator, Stream<T>... streams) {
    Stream<T> result = null;
    for (Stream<T> stream : streams) {
        if (result == null) {
            result = stream;
        } else {
            Collection<T> s = stream.collect(Collectors.toList());
            result = result.flatMap(m -> s.stream().map(n -> aggregator.apply(m, n)));
        }
    }
    return result;
}

甚至更短：

private static <T> Stream<T> cartesian(BiFunction<T, T, T> aggregator, Stream<T>... streams) {
    return Arrays.stream(streams).reduce((r, s) -> {
        List<T> collect = s.collect(Collectors.toList());
        return r.flatMap(m -> collect.stream().map(n -> aggregator.apply(m, n)));
    }).orElse(Stream.empty());
}

Answer 3

您可以创建一个方法，该方法返回一个对象的List<T>流，并且不聚合它们。算法是一样的：在每一步，将第二个流的元素收集到一个列表中，然后将它们附加到第一个流的元素中。

聚合器在方法之外。

@SuppressWarnings("unchecked")
public static <T> Stream<List<T>> cartesianProduct(Stream<T>... streams) {
    // incorrect incoming data
    if (streams == null) return Stream.empty();
    return Arrays.stream(streams)
            // non-null streams
            .filter(Objects::nonNull)
            // represent each list element as SingletonList<Object>
            .map(stream -> stream.map(Collections::singletonList))
            // summation of pairs of inner lists
            .reduce((stream1, stream2) -> {
                // list of lists from second stream
                List<List<T>> list2 = stream2.collect(Collectors.toList());
                // append to the first stream
                return stream1.flatMap(inner1 -> list2.stream()
                        // combinations of inner lists
                        .map(inner2 -> {
                            List<T> list = new ArrayList<>();
                            list.addAll(inner1);
                            list.addAll(inner2);
                            return list;
                        }));
            }).orElse(Stream.empty());
}

public static void main(String[] args) {
    Stream<String> stream1 = Stream.of("A", "B");
    Stream<String> stream2 = Stream.of("K", "L");
    Stream<String> stream3 = Stream.of("X", "Y");
    @SuppressWarnings("unchecked")
    Stream<List<String>> stream4 = cartesianProduct(stream1, stream2, stream3);
    // output
    stream4.map(list -> String.join("", list)).forEach(System.out::println);
}

String.join 在这种情况下是一种聚合器。

输出：

AKX
AKY
ALX
ALY
BKX
BKY
BLX
BLY

^{另见：Stream of cartesian product of other streams, each element as a List?}

Java 8中流的笛卡尔积作为流（仅使用流）

3 个答案: