Java中的可数和？

是否有这样的图书馆：

public class Iterables{
    private Iterables() {}

    public static <T> int sum(Iterable<T> iterable, Func<T, Integer> func) {
        int result = 0;
        for (T item : iterable)
            result += func.run(item);
        return result;
    }
}

public interface Func<TInput, TOutput> {
    TOutput run(TInput input);
}

公共类可重用性{
私有Iterables（）{}
公共静态整型和（Iterable Iterable，Func Func）{
int结果=0；
对于（T项：iterable）
结果+=功能运行（项目）；
返回结果；
}
}
公共接口函数{
TOutput运行（TInput输入）；
}

基本上有两个有用的库可以帮助实现这一点；和

您尝试做的基本上是两个操作，首先是映射，然后是归约。我自己从来没有在任何程度上使用过Commons Collections，所以我不能告诉你更多，但我知道至少谷歌番石榴（Google Guava）中不支持减少（或折叠）（请参阅）。这并不难添加您自己（未经测试）：

---

另请参见。

Java不是一种功能性语言，通常只使用普通循环更简单、更快

你可以这样写

List<String> list = /* ... */
int totalLength = Iterables.sum(list, new Func<String, Integer>() {
    public Integer run(String input) {
        return input.length();
    }
});

List List=/**/
int totalength=Iterables.sum（列表，新函数（）{
公共整数运行（字符串输入）{
返回input.length（）；
}
});

然而，我觉得写起来更简短、更简单

List<String> list = /* ... */
int totalLength = 0;
for(String s: list) totalLength += s.length();

List List=/**/
int-totalength=0；
对于（字符串s:list）totalLength+=s.length（）；

---

当闭包在Java中成为标准时，这种情况会发生变化，但目前循环通常是最好的方式。

Functional Java有一种求和方法：

下面是一个例子：

List<Integer> ints = new ArrayList<Integer>();
ints.add(1);
ints.add(2);
ints.add(3);
int sum = Integers.sum(fj.data.List.iterableList(ints));

List ints=new ArrayList（）；
加入（1）；
内加（2）；
加入（3）；
int sum=Integers.sum（fj.data.List.iterableList（ints））；

您可以简单地使用-a库以伪函数和静态类型的方式操作集合：

sum = Lambda.sum(iterable);

它还可以进行其他类型的聚合，或者您可以添加自己的聚合器：

sum = Lambda.aggregate(seq, new InitializedPairAggregator<Integer>(0) {
    protected Integer aggregate(Integer first, Integer second) {
        return first + second;
    }
});

sum=Lambda.aggregate（seq，新初始化的pairaggregator（0）{
受保护的整数聚合（整数第一，整数第二）{
返回第一个+第二个；
}
});

---

有关其他示例，请参见。

因为Java 8现在已经推出，所以获取集合的总和很简单：

collection.stream().reduce(0, Integer::sum)

不幸的是，流在iterables上不可用，但可以随时转换。阵列更容易：

LongStream.of(1, 2, 3).sum()

---

但请记住：

shorter！=更容易阅读

，这是大多数程序员都没有意识到的认知偏见。@Sridhar Sarnobat同意这一点，这是使用lambda特别是嵌套lambda时需要注意的。e、 g

a->b->a>b

很短，但不是很清楚。你能修正一下你的例子吗？我得到

类型函数中的方法apply（A）不适用于fun.apply（）行中的参数（B，A）

。可能不会。答案是5年前的，只需使用Java8流：）在Java8中，如果“values”的类型为Iterable，则可以使用StreamSupport.stream（values.spliterator（），false）来获取流

sum = Lambda.aggregate(seq, new InitializedPairAggregator<Integer>(0) {
    protected Integer aggregate(Integer first, Integer second) {
        return first + second;
    }
});

collection.stream().reduce(0, Integer::sum)

LongStream.of(1, 2, 3).sum()