Bagaimana Anda menemukan jumlah semua angka dalam array di Jawa?

Saya mengalami masalah menemukan jumlah semua bilangan bulat dalam sebuah array di Jawa. Saya tidak dapat menemukan metode yang berguna di Mathkelas untuk ini.

Di java-8 Anda dapat menggunakan stream:

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

Keluaran:

Jumlahnya 150.

Ada dalam paket java.util.stream

import java.util.stream.*;

Jika Anda menggunakan Java 8, Arrayskelas menyediakan stream(int[] array)metode yang mengembalikan berurutan IntStreamdengan intarray yang ditentukan . Itu juga telah kelebihan beban untuk doubledan longarray.

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

Ini juga menyediakan metode stream(int[] array, int startInclusive, int endExclusive)yang memungkinkan Anda untuk mengambil rentang array tertentu (yang dapat berguna):

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

Akhirnya, dapat mengambil array tipe T. Jadi Anda dapat, misalnya, memiliki Stringyang berisi angka sebagai input dan jika Anda ingin menjumlahkannya cukup lakukan:

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

Ini adalah salah satu hal sederhana yang tidak ada (AFAIK) di API Java standar. Cukup mudah untuk menulis sendiri.

Jawaban lain baik-baik saja, tetapi ada satu dengan beberapa untuk masing-masing gula sintaksis.

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

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

Juga, contoh dari penjumlahan array bahkan ditunjukkan dalam Spesifikasi Bahasa Java 7 . Contohnya adalah dari Bagian 10.4 - Akses Array .

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

Kamu tidak bisa Bahasa lain memiliki beberapa metode untuk ini seperti array_sum () di PHP, tetapi Java tidak.

Hanya..

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

System.out.println(sum);

Dalam Apache Math: Ada StatUtils.sum(double[] arr)

Satu-satunya poin yang saya tambahkan ke solusi sebelumnya adalah bahwa saya akan menggunakan waktu yang lama untuk mengakumulasi total untuk menghindari kelebihan nilai.

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

Di Java 8

Kode :

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

Output :

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

Penjelasan :

Di Java 8, Anda dapat menggunakan konsep reduksi untuk melakukan penambahan.

Baca semua tentang Pengurangan

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

IMHO fungsi penjumlahan akan tampak cocok untuk memperluas kelas Array tempat mengisi, mengurutkan, mencari, menyalin, & sama dengan hidup. Ada banyak metode praktis yang bersembunyi di javadocs sehingga merupakan pertanyaan yang wajar ketika mengirim Fortran ke java untuk ditanyakan sebelum meluncurkan metode pembantu kami sendiri. Cari melalui indeks javadoc besar untuk "jumlah", "tambahkan" dan kata kunci lain yang mungkin Anda pikirkan. Anda mungkin curiga seseorang telah melakukan ini untuk tipe primitif int, float, double, Integer, Float, Double? Tidak peduli sesederhana apa pun, selalu baik untuk memeriksa. Simpan kode sesederhana mungkin dan jangan menemukan kembali kemudi.

Saya suka metode ini secara pribadi. Gaya kode saya sedikit aneh.

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

Cukup mudah digunakan dalam kode:

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

Saya menggunakan ini:

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

Anda harus memutar sendiri.
Anda mulai dengan total 0. Kemudian Anda mempertimbangkan untuk setiap integer dalam array, tambahkan total. Kemudian ketika Anda kehabisan bilangan bulat, Anda memiliki jumlah.

Jika tidak ada bilangan bulat, maka totalnya adalah 0.

Ada dua hal yang dapat dipelajari dari latihan ini:

Anda perlu melakukan iterasi melalui elemen-elemen array dengan cara lain - Anda dapat melakukan ini dengan for for atau loop sementara. Anda perlu menyimpan hasil penjumlahan dalam akumulator. Untuk ini, Anda perlu membuat variabel.

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

Anda dapat membuat kode Anda terlihat lebih baik seperti ini:

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

Tergantung. Berapa angka yang Anda tambahkan? Menguji banyak saran di atas:

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

Saya menemukan, menggunakan mesin 8 inti, 16 G Ubuntu18, loop itu tercepat untuk nilai yang lebih kecil dan paralel untuk yang lebih besar. Tetapi tentu saja itu tergantung pada perangkat keras yang Anda jalankan:

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

Ada metode jumlah () di perpustakaan underscore-java .

Contoh kode:

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

Gunakan logika di bawah ini:

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

Tidak ada 'metode di kelas matematika' untuk hal seperti itu. Ini tidak seperti fungsi akar kuadrat atau sesuatu seperti itu.

Anda hanya perlu memiliki variabel untuk penjumlahan dan perulangan melalui array yang menambahkan setiap nilai yang Anda temukan ke penjumlahan tersebut.

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

Kami dapat menggunakan fungsi yang ditentukan pengguna. Pada awalnya, inisialisasi jumlah variabel sama dengan nol. Kemudian lintasi array dan tambahkan elemen dengan jumlah. Kemudian perbarui variabel jumlah.

Cuplikan Kode:

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

Agak kaget melihat Tak satu pun dari jawaban di atas menganggapnya bisa beberapa kali lebih cepat menggunakan kumpulan utas. Di sini, parallelgunakan fork-join thread pool dan secara otomatis memecah aliran di beberapa bagian dan menjalankannya paralel dan kemudian bergabung. Jika Anda hanya mengingat baris kode berikut, Anda dapat menggunakannya di banyak tempat.

Jadi penghargaan untuk kode pendek dan manis tercepat diberikan kepada -

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

Katakanlah Anda ingin melakukan sum of squares, lalu Arrays.stream (nums) .parallel (). Map (x-> x * x) .reduce (0, (a, b) -> a + b). Ide adalah Anda masih dapat melakukan pengurangan, tanpa peta.

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

    }

}

Pada Java 8 Penggunaan ekspresi lambda telah tersedia.

Lihat ini:

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

Kompak:

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

Lebih suka:

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

Kembalikan atau cetak jumlah.