Gibt es die Möglichkeit der Summe von ArrayList ohne Schleife

Gibt es die Möglichkeit der Summe ArrayListohne Schleife?

PHP bietet sum(array)die Summe der Arrays.

Der PHP-Code ist wie

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

Ich wollte dasselbe in Java tun:

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

Einmal Java-8ist aus (März 2014) Sie können Streams verwenden :

Wenn Sie eine haben List<Integer>

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

Wenn es ein ist int[]

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

Dann schreibe es selbst:

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

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

     return sum;
}

Die einzige Alternative zur Verwendung einer Schleife ist die Verwendung der Rekursion.

Sie können eine Methode wie definieren

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

Dies ist im Vergleich zur Verwendung einer einfachen Schleife sehr ineffizient und kann explodieren, wenn Sie viele Elemente in der Liste haben.

Eine Alternative, die einen Stapelüberlauf vermeidet, ist die Verwendung.

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

Dies ist ebenso ineffizient, vermeidet jedoch einen Stapelüberlauf.

Der kürzeste Weg, dasselbe zu schreiben, ist

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

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

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

druckt

sum(a) = 20

Schreiben Sie eine util-Funktion wie

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;
    }
}

Dann benutze gerne

int sum = ListUtil.sum(yourArrayList)

Für mich ist der klarste Weg:

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

oder

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

Es werden auch interne Schleifen verwendet, aber ohne Schleifen ist dies nicht möglich.

Sie können die Apache Commons-Collections-API verwenden.

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;
        }
    }

Verwenden Sie dann diesen Verschluss wie unten gezeigt:

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

Wenn Sie die Kartenfunktion kennen, wissen Sie, dass eine Karte auch eine rekursive Schleife oder eine rekursive Schleife sein kann. Aber dafür muss man natürlich jedes Element erreichen. Daher konnte ich Java 8 nicht ausarbeiten, da die Syntax nicht übereinstimmte, aber ich wollte eine sehr kurze Version, also habe ich diese bekommen.

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

Da eine Liste jeden Objekttyp enthalten kann, gibt es keine integrierte Methode, mit der Sie alle Elemente summieren können. Sie könnten so etwas tun:

int sum = 0;

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

Alternativ können Sie einen eigenen Containertyp erstellen, der von ArrayList erbt, aber auch eine Methode namens sum () implementiert, die den obigen Code implementiert.

ArrayList ist eine Sammlung von Elementen (in Form einer Liste), Grundelemente werden als Wrapper-Klassenobjekt gespeichert, aber gleichzeitig kann ich auch Objekte der String-Klasse speichern. SUM wird darin keinen Sinn ergeben. Übrigens, warum haben Sie sowieso solche Angst, eine Schleife (erweitert oder durch Iterator) zu verwenden?

Oder wechseln Sie zu Groovy, es hat eine sum () - Funktion für eine Sammlung. [1,2,3,4,5,6] .sum ()

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

Läuft auf derselben JVM wie Ihre Java-Klassen.

Dieser Link zeigt drei verschiedene Möglichkeiten, wie man in Java summiert. Es gibt eine Option, die in früheren Antworten mit Apache Commons Math nicht enthalten ist.

Beispiel:

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

}

Siehe StatUtils api

Sie können die GNU Trove- Bibliothek verwenden:

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

Dies kann durch Reduzieren mithilfe von Methodenreferenzen erfolgen reduce(Integer::sum):

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

Oder ohne Optional:

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