Jak zsumować listę liczb całkowitych strumieniami Java?

Chcę podsumować listę liczb całkowitych. Działa w następujący sposób, ale składnia nie wydaje się właściwa. Czy można zoptymalizować kod?

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

To zadziała, ale i -> iwykonuje automatyczne rozpakowywanie, dlatego „wydaje się” dziwne. Oba z poniższych sposobów będą działać i lepiej wyjaśnić, co kompilator robi pod maską, używając oryginalnej składni:

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

Sugeruję jeszcze 2 opcje:

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

Drugi używa Collectors.summingInt()kolektora, jest też summingLong()kolektor, którego można użyć mapToLong.

I trzecia opcja: Java 8 wprowadza bardzo skuteczny LongAdderakumulator zaprojektowany w celu przyspieszenia podsumowania w równoległych strumieniach i środowiskach wielowątkowych. Oto przykład użycia:

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

Z dokumentów

Operacje redukcji Operacja redukcji (zwana także foldem) pobiera sekwencję elementów wejściowych i łączy je w jeden wynik podsumowania poprzez wielokrotne stosowanie operacji łączenia, takiej jak znalezienie sumy lub maksimum zbioru liczb lub gromadzenie elementów w lista. Klasy strumieni mają wiele form ogólnych operacji redukcji, zwanych zmniejszeniami () i collect (), a także wiele specjalistycznych form redukcji, takich jak sum (), max () lub count ().

Oczywiście takie operacje można łatwo wdrożyć jako proste sekwencyjne pętle, jak w:

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

Istnieją jednak dobre powody, aby preferować operację zmniejszania zamiast akumulacji mutacyjnej, takiej jak powyżej. Redukcja jest nie tylko „bardziej abstrakcyjna” - działa na strumieniu jako całości, a nie na pojedynczych elementach - ale odpowiednio skonstruowana operacja redukcji jest z natury możliwa do zrównoleglenia, pod warunkiem, że funkcje zastosowane do przetwarzania elementów są skojarzone i bezpaństwowiec. Na przykład, biorąc pod uwagę strumień liczb, dla którego chcemy znaleźć sumę, możemy napisać:

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

lub:

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

Te operacje redukcji mogą przebiegać bezpiecznie równolegle, prawie bez modyfikacji:

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

Tak więc dla mapy użyłbyś:

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

Lub:

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

Możesz użyć metody zmniejszania:

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

lub

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

Możesz użyć reduce()do zsumowania listy liczb całkowitych.

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

Możesz użyć metody Collect, aby dodać listę liczb całkowitych.

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

Byłby to najkrótszy sposób na podsumowanie inttypu tablica (dla longtablicy LongStream, dla doubletablicy DoubleStreami tak dalej). StreamJednak nie wszystkie pierwotne typy całkowite lub zmiennoprzecinkowe mają implementację.

IntStream.of(integers).sum();

Może to pomóc tym, którzy mają obiekty na liście.

Jeśli masz listę obiektów i chcesz zsumować określone pola tego obiektu, skorzystaj z poniższej listy.

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

Zadeklarowałem listę liczb całkowitych.

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

Możesz spróbować użyć tych różnych sposobów poniżej.

Za pomocą mapToInt

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

Za pomocą summarizingInt

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

Za pomocą 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);

Omówiono większość aspektów. Ale może istnieć wymóg znalezienia agregacji innych typów danych oprócz Integer, Long (dla których już istnieje specjalistyczna obsługa strumienia). Na przykład stram z BigInteger W przypadku takiego typu możemy użyć operacji zmniejszania jak

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