Question

Java 8中Scala的优秀foldLeft相当于什么？

我很想认为它是reduce，但是还原必须返回与它减少的相同类型的东西。

示例：

import java.util.List;

public class Foo {

    // this method works pretty well
    public int sum(List<Integer> numbers) {
        return numbers.stream()
                      .reduce(0, (acc, n) -> (acc + n));
    }

    // this method makes the file not compile
    public String concatenate(List<Character> chars) {
        return chars.stream()
                    .reduce(new StringBuilder(""), (acc, c) -> acc.append(c)).toString();
    }
}

上面代码中的问题是acc umulator：new StringBuilder("")

因此，有人能指出我foldLeft /修复我的代码的适当等价物吗？

Answer 1

Java 8的Stream API中没有等效的foldLeft。正如其他人所指出的那样，reduce(identity, accumulator, combiner)接近，但它与foldLeft不相同，因为它要求结果类型B与自身结合并且是关联的（换句话说，类似于monoid），不是每种类型都有的财产。

此处还有一项增强请求：add Stream.foldLeft() terminal operation

要了解为什么reduce不起作用，请考虑以下代码，您打算从给定数字开始执行一系列算术运算：

val arithOps = List(('+', 1), ('*', 4), ('-', 2), ('/', 5))
val fun: (Int, (Char, Int)) => Int = {
  case (x, ('+', y)) => x + y
  case (x, ('-', y)) => x - y
  case (x, ('*', y)) => x * y
  case (x, ('/', y)) => x / y
}
val number = 2
arithOps.foldLeft(number)(fun) // ((2 + 1) * 4 - 2) / 5

如果您尝试编写reduce(2, fun, combine)，您可以通过哪种组合函数组合两个数字？将两个数字加在一起显然无法解决问题。此外，值2显然不是标识元素。

请注意，不需要按顺序执行的操作可以用reduce表示。 foldLeft实际上比reduce更通用：您可以使用reduce实施foldLeft，但无法使用foldLeft实施reduce。

Answer 2

更新：

以下是修复代码的初步尝试：

public static String concatenate(List<Character> chars) {
        return chars
                .stream()
                .reduce(new StringBuilder(),
                                StringBuilder::append,
                                StringBuilder::append).toString();
    }

它使用以下reduce method：

<U> U reduce(U identity,
                 BiFunction<U, ? super T, U> accumulator,
                 BinaryOperator<U> combiner);

这可能听起来令人困惑但是如果你看看javadocs有一个很好的解释，可以帮助你快速掌握细节。减少量等同于以下代码：

U result = identity;
for (T element : this stream)
     result = accumulator.apply(result, element)
return result;

如需更深入的解释，请查看this source。

这种用法不正确，因为它违反了reduce的约定，它指出累加器应该是一个关联的，非干扰的，无状态的函数，用于将一个额外的元素合并到结果中。换句话说，由于身份是可变的，因此在并行执行的情况下会破坏结果。

正如下面的评论中所指出的，正确的选项是使用如下缩减：

return chars.stream().collect(
     StringBuilder::new, 
     StringBuilder::append, 
     StringBuilder::append).toString();

供应商StringBuilder::new将用于创建可重复使用的容器，稍后将合并。

Answer 3

您正在寻找的方法是java.util.Stream.reduce，特别是具有三个参数的重载，标识，累加器和二进制函数。这与Scala的foldLeft相同。

但是，您允许以这种方式使用Java reduce，而不是Scala的foldLeft。请改用collect。

Answer 4

可以通过使用收集器来完成：

public static <A, B> Collector<A, ?, B> foldLeft(final B init, final BiFunction<? super B, ? super A, ? extends B> f) {
    return Collectors.collectingAndThen(
            Collectors.reducing(Function.<B>identity(), a -> b -> f.apply(b, a), Function::andThen),
            endo -> endo.apply(init)
    );
}

用法示例：

IntStream.rangeClosed(1, 100).boxed().collect(foldLeft(50, (a, b) -> a - b));  // Output = -5000

对于您的问题，这符合您的要求：

public String concatenate(List<Character> chars) {
        return chars.stream()
                .collect(foldLeft(new StringBuilder(), StringBuilder::append)).toString();
}

Answer 5

其他人是正确的，但是没有等效物。这是一个接近实用程序-

<U, T> U foldLeft(Collection<T> sequence, U identity, BiFunction<U, ? super T, U> accumulator) {
    U result = identity;
    for (T element : sequence)
        result = accumulator.apply(result, element);
    return result;
}

使用上述方法的情况看起来像-

public String concatenate(List<Character> chars) {
    return foldLeft(chars, new StringBuilder(""), StringBuilder::append).toString();
}

或者没有lambda方法引用糖，

public String concatenate(List<Character> chars) {
    return foldLeft(chars, new StringBuilder(""), (stringBuilder, character) -> stringBuilder.append(character)).toString();
}

Java 8中Scala的foldLeft的等价物

5 个答案: