如何在Java中找到数组中所有数字的总和？

Question

我在使用Java查找数组中所有整数的总和时遇到问题.我在Math课堂上找不到任何有用的方法.

Answer 1

在java-8中,您可以使用流:

int[] a = {10,20,30,40,50};
int sum = IntStream.of(a).sum();
System.out.println("The sum is " + sum);

输出:

总和是150.

它在包中 java.util.stream

import java.util.stream.*;

Answer 2

如果您使用的是Java 8,则Arrays该类提供了一个stream(int[] array)返回IntStream指定int数组的顺序的方法.它也被重载double和long阵列.

int [] arr = {1,2,3,4};
int sum = Arrays.stream(arr).sum(); //prints 10

它还提供了一种方法 stream(int[] array, int startInclusive, int endExclusive),允许您获取指定范围的数组(这可能很有用):

int sum = Arrays.stream(new int []{1,2,3,4}, 0, 2).sum(); //prints 3

最后,它可以采用一种类型的数组T.因此,您可以在每个示例中包含一个String包含数字作为输入的内容,如果您想要对它们求和,则只需:

int sum = Arrays.stream("1 2 3 4".split("\\s+")).mapToInt(Integer::parseInt).sum();

Answer 3

这是标准Java API中不存在(AFAIK)的简单事物之一.写你自己很容易.

其他答案都很好,但是这里有一些含有一些每个语法糖.

int someArray[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int sum = 0;

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

此外,Java 7语言规范中甚至还显示了数组求和的示例.该示例来自第10.4节 - 阵列访问.

class Gauss {
    public static void main(String[] args) {
        int[] ia = new int[101];
        for (int i = 0; i < ia.length; i++) ia[i] = i;
        int sum = 0;
        for (int e : ia) sum += e;
        System.out.println(sum);
    }
}

Answer 4

你不能.其他语言有一些方法,如PHP中的array_sum(),但Java没有.

只是..

int[] numbers = {1,2,3,4};
int sum = 0;
for( int i : numbers) {
    sum += i;
}

System.out.println(sum);

Answer 5

在Apache Math中:有 StatUtils.sum(double[] arr)

Answer 6

我将添加到以前的解决方案的唯一一点是,我将使用long来累积总数以避免任何溢出值.

int[] someArray = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, Integer.MAX_VALUE};
long sum = 0;

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

Answer 7

int sum = 0;

for (int i = 0; i < yourArray.length; i++)
{
  sum = sum + yourArray[i];
}

Answer 8

int sum = 0;
for (int i = 0; i < myArray.length; i++)
  sum += myArray[i];
}

Answer 9

在 Java 8

代码:

   int[] array = new int[]{1,2,3,4,5};
   int sum = IntStream.of(array).reduce( 0,(a, b) -> a + b);
   System.out.println("The summation of array is " + sum);

  System.out.println("Another way to find summation :" + IntStream.of(array).sum());

输出:

The summation of array is 15
Another way to find summation :15

说明:

在Java 8,你可以使用简化概念来做你的补充.

阅读有关减少的所有信

Answer 10

有点惊讶的是，上面的答案都没有认为使用线程池可以快很多倍。在这里，parallel使用 fork-join 线程池并自动将流分成多个部分并并行运行它们，然后合并。如果您只记住下面这行代码，您可以在很多地方使用它。

因此，最快的简短而甜蜜的代码奖颁给了 -

int[] nums = {1,2,3};
int sum =  Arrays.stream(nums).parallel().reduce(0, (a,b)-> a+b);

假设您想要执行sum of squaresArrays.stream(nums).parallel().map(x->x*x).reduce(0, (a,b)-> a+b) 操作。想法是你仍然可以执行reduce，而不需要map。

Answer 11

这取决于。您要添加多少个数字？测试上述许多建议：

import java.text.NumberFormat;
import java.util.Arrays;
import java.util.Locale;

public class Main {

    public static final NumberFormat FORMAT = NumberFormat.getInstance(Locale.US);

    public static long sumParallel(int[] array) {
        final long start = System.nanoTime();
        int sum = Arrays.stream(array).parallel().reduce(0,(a,b)->  a + b);
        final long end = System.nanoTime();
        System.out.println(sum);
        return  end - start;
    }

    public static long sumStream(int[] array) {
        final long start = System.nanoTime();
        int sum = Arrays.stream(array).reduce(0,(a,b)->  a + b);
        final long end = System.nanoTime();
        System.out.println(sum);
        return  end - start;
    }

    public static long sumLoop(int[] array) {
        final long start = System.nanoTime();
        int sum = 0;
        for (int v: array) {
            sum += v;
        }
        final long end = System.nanoTime();
        System.out.println(sum);
        return  end - start;
    }

    public static long sumArray(int[] array) {
        final long start = System.nanoTime();
        int sum = Arrays.stream(array) .sum();
        final long end = System.nanoTime();
        System.out.println(sum);
        return  end - start;
    }

    public static long sumStat(int[] array) {
        final long start = System.nanoTime();
        int sum = 0;
        final long end = System.nanoTime();
        System.out.println(sum);
        return  end - start;
    }


    public static void test(int[] nums) {
        System.out.println("------");
        System.out.println(FORMAT.format(nums.length) + " numbers");
        long p = sumParallel(nums);
        System.out.println("parallel " + FORMAT.format(p));
        long s = sumStream(nums);
        System.out.println("stream " +  FORMAT.format(s));
        long ar = sumArray(nums);
        System.out.println("arrays " +  FORMAT.format(ar));
        long lp = sumLoop(nums);
        System.out.println("loop " +  FORMAT.format(lp));

    }

    public static void testNumbers(int howmany) {
        int[] nums = new int[howmany];
        for (int i =0; i < nums.length;i++) {
            nums[i] = (i + 1)%100;
        }
        test(nums);
    }

    public static void main(String[] args) {
        testNumbers(3);
        testNumbers(300);
        testNumbers(3000);
        testNumbers(30000);
        testNumbers(300000);
        testNumbers(3000000);
        testNumbers(30000000);
        testNumbers(300000000);
    }
}

我发现，使用 8 核、16 G Ubuntu18 机器，对于较小的值，循环速度最快，对于较大的值，并行速度最快。但当然，这取决于您正在运行的硬件：

------
3 numbers
6
parallel 4,575,234
6
stream 209,849
6
arrays 251,173
6
loop 576
------
300 numbers
14850
parallel 671,428
14850
stream 73,469
14850
arrays 71,207
14850
loop 4,958
------
3,000 numbers
148500
parallel 393,112
148500
stream 306,240
148500
arrays 335,795
148500
loop 47,804
------
30,000 numbers
1485000
parallel 794,223
1485000
stream 1,046,927
1485000
arrays 366,400
1485000
loop 459,456
------
300,000 numbers
14850000
parallel 4,715,590
14850000
stream 1,369,509
14850000
arrays 1,296,287
14850000
loop 1,327,592
------
3,000,000 numbers
148500000
parallel 3,996,803
148500000
stream 13,426,933
148500000
arrays 13,228,364
148500000
loop 1,137,424
------
30,000,000 numbers
1485000000
parallel 32,894,414
1485000000
stream 131,924,691
1485000000
arrays 131,689,921
1485000000
loop 9,607,527
------
300,000,000 numbers
1965098112
parallel 338,552,816
1965098112
stream 1,318,649,742
1965098112
arrays 1,308,043,340
1965098112
loop 98,986,436

Answer 12

你必须自己动手。
从总计 0 开始。然后考虑数组中的每个整数，将其添加到总计中。然后当你没有整数时，你就得到了总和。

如果没有整数，则总数为 0。