Как суммировать список целых чисел с потоками 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();

Из документов

Операции сокращения Операция сокращения (также называемая сгибанием) берет последовательность элементов ввода и объединяет их в единый итоговый результат путем многократного применения операции объединения, такой как поиск суммы или максимума набора чисел или накопление элементов в список. Классы потоков имеют несколько форм общих операций редукции, которые называются redu () и collect (), а также несколько специализированных форм редукции, таких как sum (), max () или count ().

Конечно, такие операции могут быть легко реализованы в виде простых последовательных циклов, например:

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

Тем не менее, есть веские причины, чтобы предпочесть операцию сокращения, а не мутирующую аккумуляцию, такую ​​как описанная выше. Сокращение не только «более абстрактно» - оно работает с потоком в целом, а не с отдельными элементами, - но правильно сконструированная операция сокращения по своей сути распараллеливается, если функции, используемые для обработки элементов, являются ассоциативными. и без гражданства. Например, учитывая поток чисел, для которого мы хотим найти сумму, мы можем написать:

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);

Вы можете использовать метод уменьшить:

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);

Вы можете использовать метод сбора, чтобы добавить список целых чисел.

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

Это был бы самый короткий способ суммировать intмассив типов (для longмассива LongStream, для doubleмассива 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 (для которых уже есть поддержка специализированных потоков). Например, Stram с BigInteger. Для такого типа мы можем использовать операцию

list.stream (). Reduce ((bigInteger1, bigInteger2) -> bigInteger1.add (bigInteger2))