Existe possibilidade de soma de ArrayList sem loop

Existe possibilidade de soma ArrayListsem loop?

PHP fornece o sum(array)que dará a soma do array.

O código PHP é como

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

Eu queria fazer o mesmo em Java:

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

Uma vez java-8foi lançado (março de 2014), você poderá usar streams :

Se você tem um List<Integer>

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

Se for um int[]

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

Então escreva você mesmo:

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

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

     return sum;
}

A única alternativa para usar um loop é usar recursão.

Você pode definir um método como

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

Isso é muito ineficiente em comparação com o uso de um loop simples e pode explodir se você tiver muitos elementos na lista.

Uma alternativa que evita um estouro de pilha é usar.

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

Isso é igualmente ineficiente, mas evitará um estouro de pilha.

A maneira mais curta de escrever a mesma coisa é

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

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

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

estampas

sum(a) = 20

Escreva uma função util como

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

Então use como

int sum = ListUtil.sum(yourArrayList)

para mim a maneira mais clara é esta:

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

ou

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

Ele também usa loops internos, mas não é possível sem loops.

Você pode usar a 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;
        }
    }

Em seguida, use este fecho conforme mostrado abaixo:

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

Se você conhece a função de mapa, sabe que um mapa também pode ser um loop recursivo ou um loop recursivo. Mas obviamente você tem que alcançar cada elemento para isso. então, eu não consegui descobrir o Java 8, porque alguma incompatibilidade de sintaxe, mas queria um muito curto, então foi isso que consegui.

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

Dado que uma lista pode conter qualquer tipo de objeto, não existe um método embutido que permite somar todos os elementos. Você poderia fazer algo assim:

int sum = 0;

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

Como alternativa, você pode criar seu próprio tipo de contêiner que herda de ArrayList, mas também implementa um método chamado sum () que implementa o código acima.

ArrayList é uma coleção de elementos (na forma de lista), primitivos são armazenados como objetos da classe wrapper, mas ao mesmo tempo eu também posso armazenar objetos da classe String. SUM não fará sentido nisso. BTW, por que tem tanto medo de usar loop (aprimorado ou por meio de iterador) de qualquer maneira?

Ou mude para Groovy, ele tem uma função sum () em uma coleção. [1,2,3,4,5,6] .sum ()

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

É executado na mesma JVM que suas classes java.

Este link mostra três maneiras diferentes de somar em java, há uma opção que não está nas respostas anteriores usando o Apache Commons Math.

Exemplo:

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

}

Consulte StatUtils api

Você pode usar a biblioteca GNU Trove :

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

Isso pode ser feito com a redução usando referências de método reduce(Integer::sum):

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

Ou sem Optional:

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