Ottieni la somma di un array in Java

Per calcolare il totale di un int[] in Java, usa Arrays.stream(numbers).sum() per una soluzione concisa integrata, oppure somma ogni valore con un ciclo for quando vuoi controllare esplicitamente i passaggi. Gli array Java non dispongono di un metodo di istanza sum(); Arrays.stream(int[]) trasforma i valori in un IntStream, che fornisce sum() e reduce().
Sommare un array è una delle operazioni di base sui dati nel Tutorial Java, che ordina le guide su array e collezioni dalle basi agli stream.

Gli esempi seguenti usano gli stessi sei valori, la cui somma è 149. Ogni programma è autonomo e può essere salvato come SimpleTesting.java.

Sommare un array di int con un ciclo for

Con un ciclo normale ogni passaggio è esplicito: si inizializza l’accumulatore, si visita ogni indice e si aggiunge l’elemento corrispondente. È una scelta semplice se vuoi seguire il calcolo o aggiungere altra logica durante l’iterazione.

Questo programma somma i sei valori di numbers e ne stampa il totale. La condizione del ciclo usa numbers.length e il nome dell’array viene usato in modo coerente sia per indicarne la lunghezza sia per accedere agli elementi.

public class SimpleTesting {
  public static void main(String[] args) {
    int[] numbers = {12, 34, 45, 21, 33, 4};
    int total = 0;

    for (int i = 0; i < numbers.length; i++) {
      total += numbers[i];
    }

    System.out.println("Array Sum = " + total);
  }
}

Array Sum = 149

Sommare un array di int con uno stream parallelo e reduce

Per usare uno stream parallelo, chiama parallel() sull’IntStream restituito da Arrays.stream(numbers). Il metodo reduce a due argomenti accetta un valore identità (0) e un’operazione di addizione. Poiché l’addizione è associativa, i subtotali possono essere combinati per ottenere lo stesso risultato. Con un array breve, preferisci la versione sequenziale, a meno che l’elaborazione parallela non sia adatta al carico di lavoro complessivo: l’esecuzione parallela non rende automaticamente più rapido un calcolo piccolo.

import java.util.Arrays;

public class SimpleTesting {
  public static void main(String[] args) {
    int[] numbers = {12, 34, 45, 21, 33, 4};
    int total = Arrays.stream(numbers)
        .parallel()
        .reduce(0, (left, right) -> left + right);

    System.out.println("Array Sum = " + total);
  }
}

Array Sum = 149

Sommare un array di int con Arrays.stream(...).reduce(...)

Per creare uno stream sequenziale, ometti parallel(). Arrays.stream(int[]) restituisce comunque un IntStream; reduce(0, Integer::sum) parte dal valore identità e combina ogni valore primitivo tramite addizione. Il valore identità definisce l’operazione anche quando non ci sono valori da combinare.

import java.util.Arrays;

public class SimpleTesting {
  public static void main(String[] args) {
    int[] numbers = {12, 34, 45, 21, 33, 4};
    int total = Arrays.stream(numbers).reduce(0, Integer::sum);

    System.out.println("Array Sum = " + total);
  }
}

Array Sum = 149

Sommare un array di int con Arrays.stream(...).sum()

Quando l’operazione è un’addizione, sum() esprime l’intento più direttamente di una riduzione. È un’operazione terminale sull’IntStream ottenuto dall’array e restituisce un totale di tipo int.

Poiché questo metodo restituisce un int, il totale usa l’aritmetica intera a 32 bit di Java. Se la somma matematica può superare l’intervallo di int, converti lo stream a un tipo più ampio prima di sommare, per esempio con Arrays.stream(numbers).asLongStream().sum(). Anche il ciclo normale richiede un accumulatore long e la conversione a un tipo più ampio per gestire valori di quell’intervallo.

import java.util.Arrays;

public class SimpleTesting {
  public static void main(String[] args) {
    int[] numbers = {12, 34, 45, 21, 33, 4};
    int total = Arrays.stream(numbers).sum();

    System.out.println("Array Sum = " + total);
  }
}

Array Sum = 149

Sommare un array di int con IntStream.of(...).sum()

IntStream.of(numbers) è un altro modo diretto per creare un IntStream a partire da un int[]. La sua operazione sum() restituisce lo stesso totale di Arrays.stream(numbers).sum(). Scegli la forma che risulta più naturale nel tuo codice.

import java.util.stream.IntStream;

public class SimpleTesting {
  public static void main(String[] args) {
    int[] numbers = {12, 34, 45, 21, 33, 4};
    int total = IntStream.of(numbers).sum();

    System.out.println("Array Sum = " + total);
  }
}

Array Sum = 149

Sommare un array di int con un ciclo for compatto

Il ciclo seguente inserisce inizializzazione, condizione di continuazione e accumulo nell’intestazione del for, quindi visita l’array dall’ultimo indice al primo. È Java valido, ma il corpo vuoto e il decremento nell’espressione di aggiornamento lo rendono meno immediato da leggere rispetto al ciclo normale. Usa la forma più chiara, a meno che la compattezza non sia particolarmente utile.

public class SimpleTesting {
  public static void main(String[] args) {
    int[] numbers = {12, 34, 45, 21, 33, 4};
    int total;
    int i;

    for (total = 0, i = numbers.length - 1;
         i >= 0;
         total += numbers[i--]) {
      // Accumulation happens in the loop update expression.
    }

    System.out.println("Array Sum = " + total);
  }
}

Array Sum = 149