我在使用Java查找数组中所有整数的总和时遇到问题。我在Math类中找不到任何有用的方法。
答案 0 :(得分：232)
在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.*;
答案 1 :(得分：32)
如果您使用的是Java 8，Arrays类提供stream(int[] array)方法，该方法返回带有指定int数组的序列IntStream。 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();
答案 2 :(得分：31)
这是标准Java API中不存在（AFAIK）的简单事项之一。写自己的很容易。
其他答案完全没问题，但是这里的答案很复杂。
int someArray[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int sum = 0;
for (int i : someArray)
sum += i;
此外，数组求和的一个例子是shown in the Java 7 Language Specification。该示例来自第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);
}
}
答案 3 :(得分：18)
你做不到。其他语言有一些方法，如PHP中的array_sum（），但Java没有。
只需..
int[] numbers = {1,2,3,4};
int sum = 0;
for( int i : numbers) {
sum += i;
}
System.out.println(sum);
答案 4 :(得分：14)
在Apache Math中：有StatUtils.sum(double[] arr)
答案 5 :(得分：13)
我要添加到以前的解决方案的唯一一点是，我会使用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;
答案 6 :(得分：6)
int sum = 0;
for (int i = 0; i < yourArray.length; i++)
{
sum = sum + yourArray[i];
}
答案 7 :(得分：6)
在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中，您可以使用简化概念进行添加。
答案 8 :(得分：4)
恕我直言，求和函数似乎非常适合扩展数组类，其中填充，排序，搜索，复制和放大等于现场。有很多方便的方法隐藏在javadocs中，所以在滚动我们自己的帮助器方法之前将Fortran移植到java要求时这是一个公平的问题。在巨大的javadoc索引中搜索“sum”，“add”以及您可能想到的任何其他关键字。你可能会怀疑有人已经为原始类型int，float，double，Integer，Float，Double做了这个吗？无论多么简单，检查总是好的。保持代码尽可能简单，不要重新发明轮子。
答案 9 :(得分：3)
我个人喜欢这种方法。我的代码风格有点奇怪。
public static int sumOf(int... integers) {
int total = 0;
for (int i = 0; i < integers.length; total += integers[i++]);
return total;
}
在代码中非常容易使用：
int[] numbers = { 1, 2, 3, 4, 5 };
sumOf(1);
sumOf(1, 2, 3);
sumOf(numbers);
答案 10 :(得分：3)
int sum = 0;
for (int i = 0; i < myArray.length; i++)
sum += myArray[i];
}
答案 11 :(得分：3)
我用这个：
public static long sum(int[] i_arr)
{
long sum;
int i;
for(sum= 0, i= i_arr.length - 1; 0 <= i; sum+= i_arr[i--]);
return sum;
}
答案 12 :(得分：2)
您可以使代码看起来更像这样：
public void someMethod(){
List<Integer> numbers = new ArrayList<Integer>();
numbers.addAll(db.findNumbers());
...
System.out.println("Result is " + sumOfNumbers(numbers));
}
private int sumOfNumbers(List<Integer> numbers){
int sum = 0;
for (Integer i : numbers){
sum += i;
}
return sum;
}
答案 13 :(得分：2)
从这个练习中可以学到两件事：
您需要以某种方式遍历数组的元素 - 您可以使用for循环或while循环执行此操作。 您需要将求和结果存储在累加器中。为此，您需要创建一个变量。
int accumulator = 0;
for(int i = 0; i < myArray.length; i++) {
accumulator += myArray[i];
}
答案 14 :(得分：2)
你必须自己动手。
首先从总计0开始。然后考虑数组中的每个整数，将其添加到总数中。然后，当你没有整数时，就得到了总和。
如果没有整数，则总数为0.
答案 15 :(得分：1)
underscore-java库中有一个sum（）方法。
代码示例：
import com.github.underscore.lodash.U;
public class Main {
public static void main(String[] args) {
int sum = U.sum(java.util.Arrays.asList(1, 2, 3, 4));
System.out.println(sum);
// -> 10
}
}
答案 16 :(得分：1)
如果您专门有一个 double 类型的数组，我可以为您的问题提供正确的解决方案，那么此方法可用于计算其元素的总和。此外，它使用数学课
import org.apache.commons.math3.stat.StatUtils;
public class ArraySum {
public static void main(String[] args) {
double[] array = { 10, 4, 17, 33, -2, 14 };
int sum = (int)StatUtils.sum(array);
System.out.println("Sum of array elements is: " + sum);
}
}
答案 17 :(得分：0)
class Addition {
public static void main() {
int arr[]={5,10,15,20,25,30}; //Declaration and Initialization of an Array
int sum=0; //To find the sum of array elements
for(int i:arr) {
sum += i;
}
System.out.println("The sum is :"+sum);//To display the sum
}
}
答案 18 :(得分：0)
我们可能会使用用户定义的功能。首先初始化sum变量等于零。然后遍历数组并使用sum添加元素。然后更新sum变量。
代码段：
import java.util.*;
import java.lang.*;
import java.io.*;
class Sum
{
public static int sum(int arr[])
{
int sum=0;
for(int i=0; i<arr.length; i++)
{
sum += arr[i];
}
return sum;
}
public static void main (String[] args)
{
int arr[] = {1, 2, 3, 4, 5};
int total = sum(arr);
System.out.printf("%d", total);
}
}
答案 19 :(得分：0)
使用波纹管逻辑
static int sum()
{
int sum = 0; // initialize sum
int i;
// Iterate through all elements and add them to sum
for (i = 0; i < arr.length; i++)
sum += arr[i];
return sum;
}
答案 20 :(得分：0)
/**
* Sum of all elements from 1 to 1000
*/
final int sum = Stream.iterate(1, n -> n + 1).limit(1000).mapToInt(el -> el).sum();
答案 21 :(得分：0)
很惊讶地看到上述答案都没有考虑到使用线程池可以使它快很多倍。在这里，parallel使用fork-join线程池，并自动将流分成多个部分，并并行运行它们，然后合并。如果您只记得以下代码行，则可以在许多地方使用它。
因此，最快的简短代码获得了-
int[] nums = {1,2,3};
int sum = Arrays.stream(nums).parallel().reduce(0, (a,b)-> a+b);
让我们说你想做sum of squares，然后是Arrays.stream（nums）.parallel（）。map（x-> x * x）.reduce（0，（a，b）-> a + b）。想法是您仍然可以执行归约操作，而不需要映射。
答案 22 :(得分：0)
这取决于。您要添加多少个数字？测试上述许多建议：
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
答案 23 :(得分：0)
这里的大部分答案都是使用内置函数-
如果你想知道这个问题背后的整个逻辑，这是我的答案：
import java.util.*;
public class SumOfArray {
public static void main(String[] args){
Scanner inp = new Scanner(System.in);
int n = inp.nextInt();
int[] arr = new int[n];
for(int i = 0; i < n; i++){
arr[i] = inp.nextInt();
}
System.out.println("The sum of the array is :" + sum(arr));
}
static int sum(int[] arr){
int sum = 0;
for (int a = 0; a < arr.length; a++){
sum = sum + arr[a];
}
return sum;
}
}
答案 24 :(得分：0)
对于这样的事情，没有“数学课上的方法”。它不像它的平方根函数或类似的东西。
你只需要为sum求一个变量并循环遍历数组，将你找到的每个值加到总和中。
答案 25 :(得分：-1)
public class AddDemo {
public static void main(String[] args) {
ArrayList <Integer>A = new ArrayList<Integer>();
Scanner S = new Scanner(System.in);
System.out.println("Enter the Numbers: ");
for(int i=0; i<5; i++){
A.add(S.nextInt());
}
System.out.println("You have entered: "+A);
int Sum = 0;
for(int i=0; i<A.size(); i++){
Sum = Sum + A.get(i);
}
System.out.println("The Sum of Entered List is: "+Sum);
}
}
答案 26 :(得分：-1)
public class Num1
{
public static void main ()
{
//Declaration and Initialization
int a[]={10,20,30,40,50}
//To find the sum of array elements
int sum=0;
for(int i=0;i<a.length;i++)
{
sum=sum+i;
}
//To display the sum
System.out.println("The sum is :"+sum);
}
}
答案 27 :(得分：-3)
从Java 8开始，lambda表达式的使用已经可用。
见：
int[] nums = /** Your Array **/;
紧凑：
int sum = 0;
Arrays.asList(nums).stream().forEach(each -> {
sum += each;
});
首选：
int sum = 0;
ArrayList<Integer> list = new ArrayList<Integer>();
for (int each : nums) { //refer back to original array
list.add(each); //there are faster operations…
}
list.stream().forEach(each -> {
sum += each;
});
退还或打印金额。