如何用Java流求和一个整数列表？

我想对整数列表求和。它的工作方式如下，但是语法不正确。代码可以优化吗？

Map<String, Integer> integers;
integers.values().stream().mapToInt(i -> i).sum();

这将起作用，但是i -> i正在执行一些自动拆箱操作，这就是为什么它“感到”奇怪的原因。以下任何一种方法都可以工作，并且可以使用您的原始语法更好地解释编译器在做什么：

integers.values().stream().mapToInt(i -> i.intValue()).sum();
integers.values().stream().mapToInt(Integer::intValue).sum();

我建议另外2种选择：

integers.values().stream().mapToInt(Integer::intValue).sum();
integers.values().stream().collect(Collectors.summingInt(Integer::intValue));

第二个使用Collectors.summingInt()收集器，还有一个summingLong()您可以与使用的收集器mapToLong。

第三种选择：Java 8引入了一个非常有效的LongAdder累加器，旨在加速并行流和多线程环境中的汇总。这里是一个示例用法：

LongAdder a = new LongAdder();
map.values().parallelStream().forEach(a::add);
sum = a.intValue();

来自文档

归约运算归约运算（也称为倍数）采用一系列输入元素，并通过重复应用组合操作（例如，找到一组数字的总和或最大值）或将元素累加到一个元素中，将它们组合为单个汇总结果一个列表。流类具有多种形式的常规归约操作，称为reduce（）和collect（），以及多种专门的归约形式，例如sum（），max（）或count（）。

当然，这些操作可以很容易地实现为简单的顺序循环，例如：

int sum = 0;
for (int x : numbers) {
   sum += x;
}

但是，有充分的理由倾向于使用归约运算，而不是像上面这样的变异累积。归约不仅是“更抽象的”（它在整个流上而不是在单个元素上运行），而且，只要用于处理元素的函数具有关联性，正确构​​造的reduce操作就具有固有的可并行性。无国籍 例如，给定一个我们想求和的数字流，我们可以这样写：

int sum = numbers.stream().reduce(0, (x,y) -> x+y);

要么：

int sum = numbers.stream().reduce(0, Integer::sum);

这些还原操作几乎无需修改即可安全地并行运行：

int sum = numbers.parallelStream().reduce(0, Integer::sum);

因此，对于地图，您将使用：

integers.values().stream().mapToInt(i -> i).reduce(0, (x,y) -> x+y);

要么：

integers.values().stream().reduce(0, Integer::sum);

您可以使用reduce方法：

long sum = result.stream().map(e -> e.getCreditAmount()).reduce(0L, (x, y) -> x + y);

要么

long sum = result.stream().map(e -> e.getCreditAmount()).reduce(0L, Integer::sum);

您可以reduce()用来求和一个整数列表。

int sum = integers.values().stream().reduce(0, Integer::sum);

您可以使用collect方法添加整数列表。

List<Integer> list = Arrays.asList(2, 4, 5, 6);
int sum = list.stream().collect(Collectors.summingInt(Integer::intValue));

这将是总结int类型数组的最短方法（对于longarray LongStream，对于doublearray DoubleStream等等）。Stream尽管并非所有原始整数或浮点类型都具有实现。

IntStream.of(integers).sum();

可以帮助那些在列表上有对象的人。

如果您有对象列表，并且想要汇总该对象的特定字段，请使用以下内容。

List<ResultSom> somList = MyUtil.getResultSom();
BigDecimal result= somList.stream().map(ResultSom::getNetto).reduce(
                                             BigDecimal.ZERO, BigDecimal::add);

我已经声明了一个整数列表。

ArrayList<Integer> numberList = new ArrayList<Integer>(Arrays.asList(1, 2, 3, 4, 5));

您可以在下面尝试使用这些不同的方式。

使用 mapToInt

int sum = numberList.stream().mapToInt(Integer::intValue).sum();

使用 summarizingInt

int sum = numberList.stream().collect(Collectors.summarizingInt(Integer::intValue)).getSum();

使用 reduce

int sum = numberList.stream().reduce(Integer::sum).get().intValue();

class Pojo{
    int num;

    public Pojo(int num) {
        super();
        this.num = num;
    }

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }
}

List<Pojo> list = new ArrayList<Pojo>();
            list.add(new Pojo(1));
            list.add(new Pojo(5));
            list.add(new Pojo(3));
            list.add(new Pojo(4));
            list.add(new Pojo(5));

            int totalSum = list.stream().mapToInt(pojo -> pojo.getNum()).sum();
            System.out.println(totalSum);

涵盖了大多数方面。但是可能需要找到除Integer Long以外的其他数据类型的聚合（已提供专用流支持）。例如，使用BigInteger进行stram此类，我们可以使用reduce操作，例如

list.stream（）。reduce（（bigInteger1，bigInteger2）-> bigInteger1.add（bigInteger2））