Як підсумувати список цілих чисел з потоками 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();

Від док

Операції скорочення Операція скорочення (також звана складкою) приймає послідовність вхідних елементів і об'єднує їх в єдиний підсумковий результат шляхом повторного застосування комбінуючої операції, наприклад, знаходження суми або максимуму набору чисел або накопичення елементів у Лист. Класи потоків мають безліч форм загальних операцій скорочення, званих зменшити () і збирати (), а також безліч спеціалізованих форм зменшення, таких як сума (), макс () або кількість ().

Звичайно, такі операції можна легко реалізувати як прості послідовні петлі, як у:

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 (для якої вже існує спеціалізована підтримка потоку). Наприклад, наприклад, страйм з BigInteger Для такого типу ми можемо використовувати операцію зменшення на зразок

list.stream (). зменшити ((bigInteger1, bigInteger2) -> bigInteger1.add (bigInteger2))