Làm thế nào để bạn tìm thấy tổng của tất cả các số trong một mảng trong Java?

Tôi gặp vấn đề khi tìm tổng của tất cả các số nguyên trong một mảng trong Java. Tôi không thể tìm thấy bất kỳ phương pháp hữu ích nào trong Mathlớp cho việc này.

Trong java-8 bạn có thể sử dụng các luồng:

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

Đầu ra:

Tổng là 150.

Nó nằm trong gói java.util.stream

import java.util.stream.*;

Nếu bạn đang sử dụng Java 8, Arrayslớp cung cấp một stream(int[] array)phương thức trả về một chuỗi tuần tự IntStreamvới intmảng đã chỉ định . Nó cũng đã bị quá tải cho doublevà longmảng.

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

Nó cũng cung cấp một phương thức stream(int[] array, int startInclusive, int endExclusive)cho phép bạn lấy một phạm vi xác định của mảng (có thể hữu ích):

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

Cuối cùng, nó có thể mất một mảng các loại T. Vì vậy, mỗi ví dụ bạn có thể có một Stringsố chứa số làm đầu vào và nếu bạn muốn tính tổng chúng, hãy thực hiện:

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

Đây là một trong những điều đơn giản không tồn tại (AFAIK) trong API Java tiêu chuẩn. Nó đủ dễ để viết của riêng bạn.

Các câu trả lời khác là hoàn toàn tốt, nhưng đây là một câu với một số đường cú pháp.

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

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

Ngoài ra, một ví dụ về tổng kết mảng thậm chí còn được hiển thị trong Đặc tả ngôn ngữ Java 7 . Ví dụ là từ Phần 10.4 - Truy cập mảng .

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

Bạn không thể. Các ngôn ngữ khác có một số phương thức cho điều này như mảng_sum () trong PHP, nhưng Java thì không.

Chỉ..

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

System.out.println(sum);

Trong toán học Apache: Có StatUtils.sum(double[] arr)

Điểm duy nhất tôi sẽ thêm vào các giải pháp trước đó là tôi sẽ sử dụng một khoảng thời gian dài để tích lũy tổng số để tránh bất kỳ sự tràn giá trị nào.

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

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

int sum = 0;

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

Trong Java 8

Mã số :

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

Đầu ra :

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

Giải thích :

Trong Java 8, bạn có thể sử dụng khái niệm giảm để làm bổ sung của bạn.

Đọc tất cả về Giảm

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

IMHO một hàm tổng có vẻ phù hợp để mở rộng lớp Mảng nơi điền, sắp xếp, tìm kiếm, sao chép và bằng với trực tiếp. Có rất nhiều phương thức tiện dụng ẩn trong javadocs, vì vậy đây là một câu hỏi công bằng khi chuyển Fortran sang java để hỏi trước khi triển khai phương thức trợ giúp của chính chúng ta. Tìm kiếm thông qua chỉ số javadoc khổng lồ cho "tổng", "thêm" và bất kỳ từ khóa nào bạn có thể nghĩ đến. Bạn có thể nghi ngờ chắc chắn ai đó đã thực hiện điều này cho các kiểu nguyên thủy int, float, double, Integer, Float, Double? Cho dù đơn giản như thế nào, nó luôn luôn tốt để kiểm tra. Giữ mã đơn giản nhất có thể và không phát minh lại bánh xe.

Tôi thích phương pháp này cá nhân. Phong cách mã của tôi là một chút lạ.

public static int sumOf(int... integers) {
    int total = 0;
    for (int i = 0; i < integers.length; total += integers[i++]);
    return total;
}

Khá dễ sử dụng trong mã:

int[] numbers = { 1, 2, 3, 4, 5 };
sumOf(1);
sumOf(1, 2, 3);
sumOf(numbers);

Tôi sử dụng cái này:

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

Bạn phải tự lăn.
Bạn bắt đầu với tổng số 0. Sau đó, bạn xem xét cho mọi số nguyên trong mảng, thêm nó vào tổng số. Sau đó, khi bạn hết số nguyên, bạn có tổng.

Nếu không có số nguyên thì tổng bằng 0.

Có hai điều cần học từ bài tập này:

Bạn cần lặp lại thông qua các phần tử của mảng bằng cách nào đó - bạn có thể làm điều này với vòng lặp for hoặc vòng lặp while. Bạn cần lưu trữ kết quả của tổng kết trong một bộ tích lũy. Đối với điều này, bạn cần tạo một biến.

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

Bạn có thể làm cho mã của bạn trông tốt hơn như thế này:

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

Nó phụ thuộc. Có bao nhiêu số bạn đang thêm? Kiểm tra nhiều gợi ý trên:

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

Tôi đã tìm thấy, bằng cách sử dụng máy Ubuntu18 8 lõi, 16 G, vòng lặp nhanh nhất cho các giá trị nhỏ hơn và song song cho lớn hơn. Nhưng tất nhiên nó sẽ phụ thuộc vào phần cứng bạn đang chạy:

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

Có một phương thức sum () trong thư viện gạch dưới-java .

Mã ví dụ:

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

Sử dụng logic dưới đây:

static int sum()
     {
         int sum = 0; // initialize sum
         int i;

         // Iterate through all elements summing them up
         for (i = 0; i < arr.length; i++)
            sum +=  arr[i];

         return sum;
     }

Không có "phương pháp trong một lớp toán" cho điều đó. Nó không giống như một hàm căn bậc hai hoặc một cái gì đó tương tự.

Bạn chỉ cần có một biến cho tổng và lặp qua mảng thêm từng giá trị bạn tìm vào tổng.

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

Chúng tôi có thể sử dụng chức năng do người dùng xác định. Lúc đầu khởi tạo biến tổng bằng 0. Sau đó duyệt qua mảng và thêm phần tử với sum. Sau đó cập nhật biến tổng.

Đoạn mã:

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

/**
 * Sum of all elements from 1 to 1000
 */
final int sum = Stream.iterate(1, n -> n + 1).limit(1000).mapToInt(el -> el).sum();

Một chút ngạc nhiên khi thấy Không có câu trả lời nào ở trên cho rằng nó có thể nhanh hơn nhiều lần khi sử dụng nhóm luồng. Ở đây, parallelsử dụng nhóm luồng kết nối ngã ba và tự động ngắt luồng thành nhiều phần và chạy chúng song song và sau đó hợp nhất. Nếu bạn chỉ nhớ dòng mã sau đây, bạn có thể sử dụng nó nhiều nơi.

Vì vậy, giải thưởng cho mã ngắn và ngọt nhanh nhất thuộc về -

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

Hãy nói rằng bạn muốn làm sum of squares, sau đó Arrays.stream (nums) .pool (). Map (x-> x * x) .reduce (0, (a, b) -> a + b). Ý tưởng là bạn vẫn có thể thực hiện giảm, không cần bản đồ.

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

     }
  } 

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

    }

}

Kể từ Java 8 Việc sử dụng các biểu thức lambda đã trở nên khả dụng.

Xem cái này:

int[] nums = /** Your Array **/;

Gọn nhẹ:

int sum = 0;
Arrays.asList(nums).stream().forEach(each -> {
    sum += each;
});

Thích hơn:

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

Trả lại hoặc in tổng.