Come sommare un elenco di numeri interi con flussi Java?

Voglio riassumere un elenco di numeri interi. Funziona come segue, ma la sintassi non sembra corretta. Il codice potrebbe essere ottimizzato?

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

Funzionerà, ma i -> ista facendo unboxing automatico ed è per questo che "sembra" strano. Uno dei seguenti funzionerà e spiegherà meglio cosa sta facendo il compilatore sotto la cappa con la sintassi originale:

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

Suggerisco altre 2 opzioni:

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

Il secondo usa il Collectors.summingInt()raccoglitore, c'è anche un summingLong()raccoglitore con cui useresti mapToLong.

E una terza opzione: Java 8 introduce un LongAdderaccumulatore molto efficace progettato per accelerare il riepilogo in flussi paralleli e ambienti multi-thread. Ecco un esempio di utilizzo:

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

Dai documenti

Operazioni di riduzione Un'operazione di riduzione (chiamata anche piega) prende una sequenza di elementi di input e li combina in un unico risultato di riepilogo mediante l'applicazione ripetuta di un'operazione di combinazione, come trovare la somma o il massimo di un insieme di numeri o accumulare elementi in una lista. Le classi di flussi hanno più forme di operazioni generali di riduzione, chiamate riduzioni () e collect (), nonché più forme di riduzione specializzate come sum (), max () o count ().

Naturalmente, tali operazioni possono essere prontamente implementate come semplici cicli sequenziali, come in:

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

Tuttavia, ci sono buoni motivi per preferire un'operazione di riduzione rispetto ad un accumulo mutativo come sopra. Non solo una riduzione è "più astratta" - opera sul flusso nel suo insieme piuttosto che su singoli elementi - ma un'operazione di riduzione correttamente costruita è intrinsecamente parallelizzabile, purché le funzioni utilizzate per elaborare gli elementi siano associative e apolide. Ad esempio, dato un flusso di numeri per cui vogliamo trovare la somma, possiamo scrivere:

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

o:

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

Queste operazioni di riduzione possono essere eseguite in sicurezza in parallelo senza quasi nessuna modifica:

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

Quindi, per una mappa dovresti usare:

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

O:

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

Puoi usare il metodo di riduzione:

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

o

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

È possibile utilizzare reduce()per sommare un elenco di numeri interi.

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

È possibile utilizzare il metodo di raccolta per aggiungere un elenco di numeri interi.

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

Questo sarebbe il modo più breve per riassumere il inttipo di array (per longarray LongStream, per doublearray DoubleStreame così via). StreamTuttavia, non tutti i tipi interi primitivi o in virgola mobile hanno l' implementazione.

IntStream.of(integers).sum();

Possa questo aiutare coloro che hanno oggetti nell'elenco.

Se si dispone di un elenco di oggetti e si desidera sommare campi specifici di questo oggetto, utilizzare quanto segue.

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

Ho dichiarato un elenco di numeri interi.

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

Puoi provare a utilizzare questi diversi modi di seguito.

utilizzando mapToInt

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

utilizzando summarizingInt

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

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

La maggior parte degli aspetti sono coperti. Ma potrebbe esserci la necessità di trovare l'aggregazione di altri tipi di dati oltre a Integer, Long (per i quali è già presente il supporto di stream specializzato). Per esempio stram con BigInteger Per un tale tipo possiamo usare operazioni ridotte come

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