Czy istnieje możliwość sumowania ArrayList bez zapętlenia

Czy istnieje możliwość sumowania ArrayListbez zapętlenia?

PHP dostarcza sum(array)sumę tablicy.

Kod PHP jest podobny

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

Chciałem zrobić to samo w Javie:

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

Pewnego razu java-8jest niedostępny (marzec 2014) będziesz mógł korzystać ze strumieni :

Jeśli masz List<Integer>

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

Jeśli to int[]

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

Następnie napisz to sam:

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

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

     return sum;
}

Jedyną alternatywą dla używania pętli jest użycie rekurencji.

Możesz zdefiniować metodę, taką jak

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

Jest to bardzo nieefektywne w porównaniu do używania zwykłej pętli i może wybuchnąć, jeśli masz wiele elementów na liście.

Alternatywą, która pozwala uniknąć przepełnienia stosu, jest użycie.

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

Jest to równie nieefektywne, ale pozwoli uniknąć przepełnienia stosu.

Najkrótszym sposobem napisania tego samego jest

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

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

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

wydruki

sum(a) = 20

Napisz funkcję użytkową, taką jak

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

Następnie użyj like

int sum = ListUtil.sum(yourArrayList)

dla mnie najjaśniejszy sposób jest taki:

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

lub

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

Wykorzystuje również wewnętrzne pętle, ale bez pętli nie jest to możliwe.

Możesz użyć API apache commons-collections.

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

Następnie użyj tego zamknięcia, jak pokazano poniżej:

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

Jeśli znasz funkcję map, wiesz, że mapa może być również pętlą rekurencyjną lub pętlą rekurencyjną. Ale oczywiście musisz dotrzeć do każdego elementu. więc nie mogłem opracować Java 8, ponieważ niektóre składni nie pasują, ale chciałem być bardzo krótki, więc oto, co otrzymałem.

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

Biorąc pod uwagę, że lista może zawierać dowolne typy obiektów, nie ma wbudowanej metody, która pozwala zsumować wszystkie elementy. Możesz zrobić coś takiego:

int sum = 0;

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

Alternatywnie możesz utworzyć własny typ kontenera, który dziedziczy po ArrayList, ale także implementuje metodę o nazwie sum (), która implementuje powyższy kod.

ArrayList to zbiór elementów (w formie listy), prymitywne są przechowywane jako obiekty klasy wrapper, ale jednocześnie mogę przechowywać również obiekty klasy String. SUM nie będzie miał w tym sensu. A tak przy okazji, dlaczego tak się boisz używać pętli for (ulepszonej lub przez iterator)?

Lub przełącz się na Groovy, ma funkcję sum () w kolekcji. [1,2,3,4,5,6]. Suma ()

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

Działa na tej samej maszynie JVM, co Twoje klasy Java.

Ten link pokazuje trzy różne sposoby sumowania w Javie. Jest jedna opcja, której nie ma w poprzednich odpowiedziach przy użyciu Apache Commons Math.

Przykład:

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

}

Zobacz StatUtils api

Możesz użyć biblioteki GNU Trove :

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

Można to zrobić za pomocą metody Redukcja przy użyciu odwołań do metod reduce(Integer::sum):

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

Lub bez Optional:

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