Java 的 Stream.flatMap（） 的（某种）逆运算是什么？

你可以破解你的方式。请参阅以下示例：

Stream<List<String>> stream = Stream.of("Cat", "Dog", "Whale", "Mouse")
   .collect(Collectors.collectingAndThen(
       Collectors.partitioningBy(a -> a.length() > 3),
       map -> Stream.of(map.get(true), map.get(false))
    ));

这是我想出的：

interface OptionalBinaryOperator<T> extends BiFunction<T, T, Optional<T>> {
  static <T> OptionalBinaryOperator<T> of(BinaryOperator<T> binaryOperator,
          BiPredicate<T, T> biPredicate) {
    return (t1, t2) -> biPredicate.test(t1, t2)
            ? Optional.of(binaryOperator.apply(t1, t2))
            : Optional.empty();
  }
}

class StreamUtils {
  public static <T> Stream<T> reducePartially(Stream<T> stream,
          OptionalBinaryOperator<T> conditionalAccumulator) {
    Stream.Builder<T> builder = Stream.builder();
    stream.reduce((t1, t2) -> conditionalAccumulator.apply(t1, t2).orElseGet(() -> {
      builder.add(t1);
      return t2;
    })).ifPresent(builder::add);
    return builder.build();
  }
}

不幸的是，我没有时间让它变得懒惰，但可以通过编写一个自定义委托来完成，该委托将遵循上述逻辑（而不是利用 ，这是一个终端操作）。Spliteratorstream.spliterator()stream.reduce()

---

我刚刚意识到你想要皈依，我写了关于皈依的文章。如果可以先映射 from to ，然后使用上面的函数，那么就是这样（即使它不是最优的）。<T,U><T,T>TU

如果它更复杂，则需要在提出 API 之前定义减少/合并的条件类型（例如 ， ， ， 甚至 ）。Predicate<T>BiPredicate<T,T>BiPredicate<U,T>Predicate<List<T>>

    IntStream.range(0, 10)
            .mapToObj(n -> IntStream.of(n, n / 2, n / 3))
            .reduce(IntStream.empty(), IntStream::concat)
            .forEach(System.out::println);

如您所见，元素也被映射到 Streams，然后连接成一个大流。

在 StreamEx 中查看collapse

StreamEx.of("a1", "a2", "c1", "c2", "c3").collapse((a, b) -> a.charAt(0) == b.charAt(0))
    .map(e -> e.substring(0, 1)).forEach(System.out::println);

或者我的叉子有更多功能：、、......groupBysplitsliding

StreamEx.of("a1", "a2", "c1", "c2", "c3").collapse((a, b) -> a.charAt(0) == b.charAt(0))
.map(e -> e.substring(0, 1)).forEach(System.out::println);
// a
// c

StreamEx.of("a1", "a2", "c1", "c2", "c3").splitToList(2).forEach(System.out::println);
// [a1, a2]
// [c1, c2]
// [c3]

StreamEx.of("a1", "a2", "c1", "c2", "c3").groupBy(e -> e.charAt(0))
.forEach(System.out::println);
// a=[a1, a2]
// c=[c1, c2, c3]

最后，我发现这是它自己的“逆向”，可以这么说。我监督说，这并不一定会增加元素的数量。它还可以通过为某些元素发出空流来减少元素的数量。为了实现 group-by 操作，调用 by 的函数需要最少的内部状态，即最新的元素。它要么返回一个空流，要么在组结束时返回简化为组的代表。flatMapflatMapflatMap

这是一个快速实现，如果传入的两个元素不属于同一个组，即它们之间是组边界，则必须返回。是将 （1，a）、（1，a）、（1，a） 组合成 （3，a） 的组函数，假设您的组元素是元组 （int， string）。groupBordertruecombiner

public class GroupBy<X> implements Function<X, Stream<X>>{

  private final BiPredicate<X, X> groupBorder;
  private final BinaryOperator<X> combiner;
  private X latest = null;

  public GroupBy(BiPredicate <X, X> groupBorder,
                 BinaryOperator<X> combiner) {
    this.groupBorder = groupBorder;
    this.combiner = combiner;
  }

  @Override
  public Stream<X> apply(X elem) {
    // TODO: add test on end marker as additonal parameter for constructor
    if (elem==null) {
      return latest==null ? Stream.empty() : Stream.of(latest);
    }
    if (latest==null) {
      latest = elem;
      return Stream.empty();
    }
    if (groupBorder.test(latest, elem)) {
      Stream<X> result = Stream.of(latest);
      latest = elem;
      return result;
    }
    latest = combiner.apply(latest,  elem);
    return Stream.empty();
  }
}

但有一点需要注意：要传送整个流的最后一组，必须将结束标记作为最后一个元素卡在流中。上面的代码假设它是 ，但可以添加一个额外的 end-marker-tester。null

我无法想出一个不依赖于结束标记的解决方案。

此外，我也没有在传入和传出元素之间进行转换。对于唯一操作，这将起作用。对于计数操作，上一步必须将单个元素映射到计数对象。

有点像 StreamEx，您可以手动实现 Spliterator。例如

collectByTwos(Stream.of(1, 2, 3, 4), (x, y) -> String.format("%d%d", x, y))

...使用以下代码返回“12”、“34”流：

public static <X,Y> Stream<Y> collectByTwos(Stream<X> inStream, BiFunction<X,X,Y> mapping) {
    Spliterator<X> origSpliterator = inStream.spliterator();
    Iterator<X> origIterator = Spliterators.iterator(origSpliterator);

    boolean isParallel = inStream.isParallel();
    long newSizeEst = (origSpliterator.estimateSize() + 1) / 2;

    Spliterators.AbstractSpliterator<Y> lCombinedSpliterator =
            new Spliterators.AbstractSpliterator<>(newSizeEst, origSpliterator.characteristics()) {
        @Override
        public boolean tryAdvance(Consumer<? super Y> action) {
            if (! origIterator.hasNext()) {
                return false;
            }
            X lNext1 = origIterator.next();
            if (! origIterator.hasNext()) {
                throw new IllegalArgumentException("Trailing elements of the stream would be ignored.");
            }
            X lNext2 = origIterator.next();
            action.accept(mapping.apply(lNext1, lNext2));
            return true;
        }
    };
    return StreamSupport.stream(lCombinedSpliterator, isParallel)
            .onClose(inStream::close);
}

（我认为这对于并行流可能是不正确的。

主要得益于 user_3380739 上面的 StreamEx 答案，您可以在此处使用文档groupRuns

StreamEx.of("a1", "a2", "c1", "c2", "c3").groupRuns( t, u -> t.charAt(0) == u.charAt(0) )
.forEach(System.out::println);

// a=[a1, a2]
// c=[c1, c2, c3]