Question

是否有可能ArrayList没有循环？

PHP提供sum(array)，它将给出数组的总和。

PHP代码就像

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

我想在Java中做同样的事情：

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

Answer 1

java-8结束后（2014年3月），您将能够use streams：

如果您有List<Integer>

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

如果是int[]

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

Answer 2

然后自己写一下：

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

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

     return sum;
}

Answer 3

编写像

这样的util函数

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

然后使用

int sum = ListUtil.sum(yourArrayList)

Answer 4

使用循环的唯一选择是使用递归。

您可以定义类似

的方法

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

与使用普通循环相比，这是非常低效的，如果列表中有许多元素，则会爆炸。

使用避免堆栈溢出的替代方法。

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

这样效率低，但会避免堆栈溢出。

编写相同内容的最短路径是

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

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

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

打印

sum(a) = 20

Answer 5

for me the clearest way is this:

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

or

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

It also use internal loops, but it is not possible without loops.

Answer 6

您可以使用apache commons-collections API。

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

然后使用此闭包，如下所示：

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

Answer 7

如果您了解map函数，那么您就知道map也可以是递归循环或递归循环。但显然你必须达到每个元素。所以，我无法解决Java 8问题，因为一些语法不匹配但需要很短的时间，所以这就是我得到的。

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

Answer 8

鉴于列表可以包含任何类型的对象，没有内置方法允许您对所有元素求和。你可以这样做：

int sum = 0;

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

或者你可以创建自己的容器类型，它继承自ArrayList，但也实现了一个名为sum（）的方法，它实现了上面的代码。

Answer 9

ArrayList是 Collection 元素（以列表的形式），原语存储为包装类对象，但同时我也可以存储String类的对象。 SUM在这方面没有意义。 BTW为什么如此害怕使用for循环（增强或通过迭代器）呢？

Answer 10

或者切换到Groovy，它在集合上有一个sum（）函数。 [1,2,3,4,5,6]的.sum（）

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

在与java类相同的JVM上运行。

Answer 11

这个link显示了如何在java中求和的三种不同方法，有一个选项在以前的答案中没有使用Apache Commons Math ..

示例：

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

}

请参阅StatUtils api

Answer 12

您可以使用GNU Trove库：

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

Answer 13

这可以通过使用方法引用reduce(Integer::sum)的reduce来完成：

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

或者没有Optional：

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

是否有可能没有循环的ArrayList的总和

13 个答案: