Wie finden Sie die Summe aller Zahlen in einem Array in Java?

Ich habe ein Problem beim Finden der Summe aller Ganzzahlen in einem Array in Java. Ich kann dafür keine nützliche Methode in der MathKlasse finden.

Im Java-8 Sie können Streams verwenden:

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

Ausgabe:

Die Summe beträgt 150.

Es ist im Paket java.util.stream

import java.util.stream.*;

Wenn Sie Java 8 verwenden, stellt die ArraysKlasse eine stream(int[] array)Methode bereit , die eine Sequenz IntStreammit dem angegebenen intArray zurückgibt . Es wurde auch für doubleund longArrays überladen .

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

Es bietet auch eine Methode, mit stream(int[] array, int startInclusive, int endExclusive)der Sie einen bestimmten Bereich des Arrays übernehmen können (was nützlich sein kann):

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

Schließlich kann es ein Array vom Typ annehmen T. Sie können also per Beispiel eine haben, Stringdie Zahlen als Eingabe enthält, und wenn Sie sie summieren möchten, tun Sie einfach:

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

Dies ist eines der einfachen Dinge, die in der Standard-Java-API nicht vorhanden sind (AFAIK). Es ist einfach genug, eigene zu schreiben.

Andere Antworten sind vollkommen in Ordnung, aber hier ist eine mit etwas für jeden syntaktischen Zucker.

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

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

Ein Beispiel für die Array-Summierung finden Sie sogar in der Java 7-Sprachspezifikation . Das Beispiel stammt aus Abschnitt 10.4 - Array-Zugriff .

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

Das kannst du nicht. Andere Sprachen haben einige Methoden dafür wie array_sum () in PHP, Java jedoch nicht.

Gerade..

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

System.out.println(sum);

In Apache Math: Es gibt StatUtils.sum(double[] arr)

Der einzige Punkt, den ich zu früheren Lösungen hinzufügen würde, ist, dass ich einen Long verwenden würde, um die Summe zu akkumulieren, um einen Wertüberlauf zu vermeiden.

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

Im Java 8

Code :

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

Ausgabe :

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

Erklärung :

In Java 8können Sie das Reduktionskonzept verwenden, um Ihre Addition durchzuführen.

Lesen Sie alles über Reduktion

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

IMHO scheint eine Summenfunktion gut geeignet zu sein, um die Arrays-Klasse zu erweitern, in der Füllen, Sortieren, Suchen, Kopieren und Gleiches live sind. Es gibt viele praktische Methoden, die sich in den Javadocs verstecken. Daher ist es eine faire Frage, wenn Sie Fortran nach Java portieren, bevor Sie unsere eigene Hilfsmethode verwenden. Durchsuchen Sie den riesigen Javadoc-Index nach "sum", "add" und jedem anderen Schlüsselwort, an das Sie denken könnten. Sie könnten vermuten, dass dies bereits jemand für primitive Typen int, float, double, Integer, Float, Double getan hat? Egal wie einfach, es ist immer gut zu überprüfen. Halten Sie den Code so einfach wie möglich und erfinden Sie das Rad nicht neu.

Ich mag diese Methode persönlich. Mein Codestil ist etwas komisch.

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

Ziemlich einfach im Code zu verwenden:

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

Ich benutze das:

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

Du musst deine eigenen rollen.
Sie beginnen mit einer Summe von 0. Dann überlegen Sie, ob Sie für jede Ganzzahl im Array eine Summe hinzufügen möchten. Wenn Sie dann keine ganzen Zahlen mehr haben, haben Sie die Summe.

Wenn es keine ganzen Zahlen gab, ist die Summe 0.

Aus dieser Übung können Sie zwei Dinge lernen:

Sie müssen die Elemente des Arrays irgendwie durchlaufen - Sie können dies mit einer for-Schleife oder einer while-Schleife tun. Sie müssen das Ergebnis der Summierung in einem Akkumulator speichern. Dazu müssen Sie eine Variable erstellen.

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

Sie können Ihren Code folgendermaßen besser aussehen lassen:

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

In Unterstrich-Java gibt es eine sum () -Methode Bibliothek .

Codebeispiel:

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

Verwenden Sie die folgende Logik:

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

Es hängt davon ab, ob. Wie viele Zahlen fügen Sie hinzu? Testen vieler der oben genannten Vorschläge:

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

Ich fand heraus, dass mit einer 8-Kern-16-G-Ubuntu18-Maschine die Schleife für kleinere Werte am schnellsten und die Parallele für größere Werte am schnellsten war. Aber natürlich hängt es von der Hardware ab, die Sie ausführen:

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

Es gibt keine "Methode in einer Matheklasse" für so etwas. Es ist nicht so, als wäre es eine Quadratwurzelfunktion oder so etwas.

Sie müssen nur eine Variable für die Summe haben und das Array durchlaufen, um jeden gefundenen Wert zur Summe hinzuzufügen.

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

Wir können benutzerdefinierte Funktionen verwenden. Initialisieren Sie zunächst die Summenvariable gleich Null. Durchlaufen Sie dann das Array und fügen Sie das Element mit der Summe hinzu. Aktualisieren Sie dann die Summenvariable.

Code-Auszug :

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

Ein bisschen überrascht zu sehen Keine der obigen Antworten geht davon aus, dass die Verwendung eines Thread-Pools um ein Vielfaches schneller sein kann. Hier parallelverwendet eine Gabel-Join - Thread - Pool und automatisch den Strom in mehrere Teile brechen und laufen sie parallel und dann verschmelzen. Wenn Sie sich nur an die folgende Codezeile erinnern, können Sie sie an vielen Stellen verwenden.

Die Auszeichnung für den schnellsten kurzen und süßen Code geht also an -

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

Nehmen wir an, Sie möchten dies tun sum of squares, dann Arrays.stream (nums) .parallel (). Map (x-> x * x) .reduce (0, (a, b) -> a + b). Die Idee ist, dass Sie ohne Karte immer noch eine Reduzierung durchführen können.

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

    }

}

Ab Java 8 Die Verwendung von Lambda-Ausdrücken ist verfügbar geworden.

Sieh dir das an:

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

Kompakt:

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

Bevorzugen:

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

Summe zurückgeben oder drucken.