Java'daki bir dizideki tüm sayıların toplamını nasıl bulursunuz?

Java bir dizideki tüm tamsayıların toplamını bulmada bir sorun yaşıyorum. Bunun için Mathsınıfta herhangi bir yararlı yöntem bulamıyorum .

İçinde Java-8 akışları kullanabilirsiniz:

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

Çıktı:

Toplam 150'dir.

Pakette java.util.stream

import java.util.stream.*;

Java 8 kullanıyorsanız, Arrayssınıf belirtilen diziyle stream(int[] array)sıralı dönen bir yöntem sağlar . Aynı zamanda ve diziler için aşırı yüklendi .IntStreamintdoublelong

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

Ayrıca stream(int[] array, int startInclusive, int endExclusive), dizinin belirli bir aralığını almanıza izin veren bir yöntem de sağlar (kullanışlı olabilir):

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

Son olarak, bir dizi yazı alabilir T. Böylece, örnek Stringolarak giriş olarak sayı içeren bir tane olabilir ve bunları toplamak istiyorsanız sadece şunu yapın:

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

Bu, standart Java API'sinde olmayan (AFAIK) basit şeylerden biridir. Kendinizinkini yazmak yeterince kolaydır.

Diğer cevaplar gayet iyi, ama burada her biri için sözdizimsel şekeri olan bir tane var.

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

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

Ayrıca, dizi toplamının bir örneği Java 7 Dil Spesifikasyonu'nda bile gösterilir . Örnek Bölüm 10.4 - Dizi Erişimi'dir .

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

Yapamazsın. Diğer dillerde bunun PHP için array_sum () gibi bazı yöntemleri vardır, ancak Java yoktur.

Sadece..

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

System.out.println(sum);

Apache Math'da: Var StatUtils.sum(double[] arr)

Önceki çözümlere ekleyeceğim tek nokta, değerin taşmasını önlemek için toplamı biriktirmek için uzun süre kullanacağım.

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

İçinde Java 8

Kod :

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

Çıktı :

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

Açıklama :

İçinde Java 8, ekleme yapmak için azaltma kavramını kullanabilirsiniz.

Redüksiyon hakkında her şeyi okuyun

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

IMHO, bir toplama işlevi, doldurma, sıralama, arama, kopyalama ve eşittirlerin yaşandığı Arrays sınıfını genişletmek için uygun görünecektir. Javadoclarda saklanan birçok kullanışlı yöntem var, bu yüzden Fortran'ı java'ya taşıdığımızda kendi yardımcı yöntemimizi yuvarlamadan önce sormak adil bir soru. Büyük javadoc dizininde "toplam", "ekle" ve aklınıza gelebilecek diğer anahtar kelimeleri arayın. Birisinin bunu zaten ilkel türler için yapmış olduğundan şüphelenebilirsiniz int, float, double, Integer, Float, Double? Ne kadar basit olursa olsun, kontrol etmek her zaman iyidir. Kodu olabildiğince basit tutun ve tekerleği yeniden icat etmeyin.

Bu yöntemi şahsen seviyorum. Kod tarzım biraz garip.

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

Kodda kullanımı oldukça kolay:

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

Bunu kullanıyorum:

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

Kendinizi yuvarlamanız gerekiyor.
Toplam 0 ile başlar. Sonra dizideki her tamsayı için düşünün, bir toplam ekleyin. Sonra tamsayıların dışında, toplam var.

Tam sayı yoksa, toplam 0'dır.

Bu alıştırmadan öğrenilecek iki şey var:

Bir şekilde dizinin öğeleri arasında yineleme yapmanız gerekir - bunu bir for döngüsü veya while döngüsü ile yapabilirsiniz. Toplamın sonucunu bir akümülatörde saklamanız gerekir. Bunun için bir değişken oluşturmanız gerekir.

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

Kodunuzu şu şekilde daha iyi gösterebilirsiniz:

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

Değişir. Kaç numara ekliyorsunuz? Yukarıdaki önerilerin çoğunu test etme:

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 çekirdekli, 16 G Ubuntu18 makinesi kullanarak, döngü daha küçük değerler için en hızlı ve daha büyükler için paraleldi. Ancak elbette, çalıştırdığınız donanıma bağlı olacaktır:

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

Alt çizgi-java kütüphanesinde bir sum () yöntemi vardır .

Kod örneği:

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

Aşağıdaki mantığı kullanın:

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

Böyle bir şey için 'matematik sınıfında yöntem' yoktur. Onun karekök fonksiyonu ya da bunun gibi bir şey gibi değil.

Toplam için bir değişkeninizin olması ve toplamda bulduğunuz her bir değeri ekleyerek dizi boyunca döngü sağlamanız gerekir.

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

Kullanıcı tanımlı fonksiyon kullanabiliriz. İlk olarak, toplam değişkenini sıfıra eşitleyin. Sonra dizi arasında gezinin ve sum ile öğe ekleyin. Ardından toplam değişkenini güncelleyin.

Kod Parçacığı:

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

Görmek biraz şaşırttı Yukarıdaki cevapların hiçbiri bir iş parçacığı havuzu kullanarak birden çok kez daha hızlı olabileceğini düşünmüyor. Burada, parallelçatal birleştirme iş parçacığı havuzu kullanır ve akışı otomatik olarak birden çok parçaya ayırır ve paralel olarak çalıştırır ve birleştirir. Aşağıdaki kod satırını hatırlarsanız, birçok yerde kullanabilirsiniz.

Bu yüzden en hızlı kısa ve tatlı kod ödülü -

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

Yapmak istediğinizi sum of squaressöyleyelim, sonra Arrays.stream (nums) .parallel (). Map (x-> x * x). İndir (0, (a, b) -> a + b). Fikir, harita olmadan hala azaltma gerçekleştirebilirsiniz.

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

    }

}

Java 8'den itibaren Lambda ifadelerinin kullanımı kullanıma sunulmuştur.

Bunu gör:

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

Kompakt:

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

Tercih etmek:

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

İade veya baskı toplamı.