在Java中折叠顺序流

Question

我习惯了用Scala编程，但我必须编写一些Java，我正在尝试执行相当于以下Scala片段的操作：

trait Options[K, V] {
  def add(key: K , value: V): Options[K, V]
}

val options: Options[T, U] = ???
val elems: List[(T, U)] = ???
elems.foldLeft(options) {
  case (opts, (key, value)) => opts.add(key, value)
}

也就是说，我在选项中折叠元素，在每个步骤中生成一个新实例。

我试着使用Java的流reduce：

interface Options<K, V> {
  Options<K, V> add(K key, V value);
}

Options<K, V> options = ???
Stream<Tuple2<K, V>> elems = ??? // This is Reactor's Tuple2
elems.reduce(options, (opts, opt) -> opts.add(opt), ???)

我不知道合并器应该是什么，我很难想象它的参数会有什么价值。我的理解是，组合器将用于组合并行流中并行生成的中间值。在我的例子中，我根本不关心并行处理元素。换句话说，我正在寻找一个同步和顺序版本的Flux#reduce。

我无法控制选项的API<代码>元素不需要是流。




Answer 1

使用您提供的接口编写组合器是不可能的。问题是组合器需要一种方法来组合两个Options，但没有办法做到这一点。任何人都可以使用Options实例做的唯一事情是向其添加一对。我无法从中获取任何信息。它大概不能做任何非常有用的事情。

这个问题可能源于这样一个事实：Java没有trait，Java接口也不是trait的合适替代品。

编写这篇文章的惯用Java方法只是循环的bog标准：

Options<String, String> options = /*whatever*/;
List<Pair<String, String>> elems = /*whatever*/;
for (Pair<String, String> pair : elems)
{
    options = options.add(pair.getKey(), pair.getValue());
}

如果您能够处理这样一个事实，即您永远无法使用并行流，那么您可以利用这样一个事实，即顺序流实际上永远不会使用组合器。因此，您可以编写一个收集器，该收集器定义一个只会引发异常的组合器。

Options<String, String> foo = elems.stream()
    .collect(
        () -> options,
        (opt, pair) -> opt.add(pair.getKey(), pair.getValue()),
        (a, b) -> { throw new UnsupportedOperationException(); }
    );

如果确实要使用reduce，则需要修改界面，以公开有关其包含的键值对的一些信息，或提供一种方法，一次添加多个键值对。例如：

interface Options<K, V>
{
    Options<K, V> add(K key, V value);
    Options<K, V> add(Options<K, V> otherOptions);
}

Options<String, String> options = /*whatever*/;
List<Pair<String, String>> elems = /*whatever*/;

Options<String, String> foo = elems.stream()
    .reduce(
        options,
        (opt, pair) -> opt.add(pair.getKey(), pair.getValue()),
        Options::add
    );

我怀疑这是你想听到的，但是Scala和Java是不同的语言。你不应该期望所有的东西都有完全的相似之处。如果是这样，这两种语言就没有理由存在。