C'è la possibilità di somma di ArrayList senza loop

C'è la possibilità di somma ArrayListsenza loop?

PHP fornisce sum(array)che darà la somma di array.

Il codice PHP è come

$a = array(2, 4, 6, 8);
echo "sum(a) = " . array_sum($a) . "\n";

Volevo fare lo stesso in Java:

List tt = new ArrayList();
tt.add(1);
tt.add(2);
tt.add(3);

Una volta java-8è uscito (marzo 2014) potrai utilizzare gli stream :

Se hai un List<Integer>

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

Se è un file int[]

int sum = IntStream.of(a).sum();

Quindi scrivilo tu stesso:

public int sum(List<Integer> list) {
     int sum = 0; 

     for (int i : list)
         sum = sum + i;

     return sum;
}

L'unica alternativa all'uso di un ciclo è usare la ricorsione.

Puoi definire un metodo come

public static int sum(List<Integer> ints) {
   return ints.isEmpty() ? 0 : ints.get(0) + ints.subList(1, ints.length());
}

Questo è molto inefficiente rispetto all'utilizzo di un semplice loop e può saltare in aria se si hanno molti elementi nell'elenco.

Un'alternativa che evita un overflow dello stack è usare.

public static int sum(List<Integer> ints) {
    int len = ints.size();
    if (len == 0) return 0;
    if (len == 1) return ints.get(0);
    return sum(ints.subList(0, len/2)) + sum(ints.subList(len/2, len));
}

Questo è altrettanto inefficiente, ma eviterà un overflow dello stack.

Il modo più breve per scrivere la stessa cosa è

int sum = 0, a[] = {2, 4, 6, 8};

for(int i: a) {
    sum += i;
}

System.out.println("sum(a) = " + sum);

stampe

sum(a) = 20

Scrivi una funzione util come

public class ListUtil{

    public static int sum(List<Integer> list){
      if(list==null || list.size()<1)
        return 0;

      int sum = 0;
      for(Integer i: list)
        sum = sum+i;

      return sum;
    }
}

Quindi usa mi piace

int sum = ListUtil.sum(yourArrayList)

per me il modo più chiaro è questo:

doubleList.stream().reduce((a,b)->a+b).get();

o

doubleList.parallelStream().reduce((a,b)->a+b).get();

Utilizza anche loop interni, ma non è possibile senza loop.

Puoi utilizzare l'API delle collezioni comuni di apache.

class AggregateClosure implements org.apache.commons.collections.Closure {
        int total = 0;

        @Override
        public void execute(Object input) {
            if (input != null) {
                total += (Integer) input;
            }
        }

        public int getTotal() {
            return total;
        }
    }

Quindi utilizzare questa chiusura come mostrato di seguito:

public int aggregate(List<Integer> aList) {
        AggregateClosure closure = new AggregateClosure();
        org.apache.commons.collections.CollectionUtils.forAllDo(aList, closure);
        return closure.getTotal();
}

Se conosci la funzione mappa, allora sai che una mappa può anche essere un ciclo ricorsivo o un ciclo ricorsivo. Ma ovviamente devi raggiungere ogni elemento per questo. quindi, non sono riuscito a risolvere Java 8, perché un po 'di mancata corrispondenza della sintassi ma volevo un molto breve quindi questo è quello che ho ottenuto.

int sum = 0
for (Integer e : myList) sum += e;

Dato che un elenco può contenere qualsiasi tipo di oggetto, non esiste un metodo integrato che consenta di sommare tutti gli elementi. Potresti fare qualcosa del genere:

int sum = 0;

for( Integer i : ( ArrayList<Integer> )tt ) {
  sum += i;
}

In alternativa puoi creare il tuo tipo di contenitore che eredita da ArrayList ma implementa anche un metodo chiamato sum () che implementa il codice sopra.

ArrayList è una raccolta di elementi (sotto forma di lista), le primitive vengono memorizzate come oggetto della classe wrapper ma allo stesso tempo posso memorizzare anche oggetti della classe String. SOMMA non avrà senso in questo. A proposito, perché hanno così paura di usare il ciclo for (migliorato o tramite iteratore) comunque?

Oppure passa a Groovy, ha una funzione sum () su una raccolta. [1,2,3,4,5,6] .somma ()

http://groovy.codehaus.org/JN1015-Collections

Funziona sulla stessa JVM delle classi Java.

Questo collegamento mostra tre diversi modi per sommare in java, c'è un'opzione che non è nelle risposte precedenti usando Apache Commons Math ..

Esempio:

public static void main(String args []){
    List<Double> NUMBERS_FOR_SUM = new ArrayList<Double>(){
         {
            add(5D);
            add(3.2D);
            add(7D);
         }
    };
    double[] arrayToSume = ArrayUtils.toPrimitive(NUMBERS_FOR_SUM
            .toArray(new Double[NUMBERS_FOR_SUM.size()]));    
    System.out.println(StatUtils.sum(arrayToSume));

}

Vedere StatUtils api

Puoi usare la libreria GNU Trove :

TIntList tt = new TIntArrayList();
tt.add(1);
tt.add(2);
tt.add(3);
int sum = tt.sum();

Questo può essere fatto con reduce usando i riferimenti al metodo reduce(Integer::sum):

Integer reduceSum = Arrays.asList(1, 3, 4, 6, 4)
        .stream()
        .reduce(Integer::sum)
        .get();

Oppure senza Optional:

Integer reduceSum = Arrays.asList(1, 3, 4, 6, 4)
        .stream()
        .reduce(0, Integer::sum);