Jak znaleźć sumę wszystkich liczb w tablicy w Javie?

Mam problem ze znalezieniem sumy wszystkich liczb całkowitych w tablicy w Javie. W tej Mathklasie nie mogę znaleźć żadnej użytecznej metody .

W java-8 możesz używać strumieni:

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

Wynik:

Suma wynosi 150.

Jest w opakowaniu java.util.stream

import java.util.stream.*;

Jeśli używasz języka Java 8, Arraysklasa udostępnia stream(int[] array)metodę, która zwraca sekwencję IntStreamz określoną inttablicą. Został również przeciążony dla tablic doublei long.

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

Udostępnia również metodę, stream(int[] array, int startInclusive, int endExclusive)która pozwala na pobranie określonego zakresu tablicy (co może być przydatne):

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

Wreszcie może przyjąć tablicę typu T. Możesz więc na przykład mieć, Stringktóry zawiera liczby jako dane wejściowe i jeśli chcesz je zsumować, po prostu wykonaj:

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

Jest to jedna z tych prostych rzeczy, których (AFAIK) nie ma w standardowym interfejsie API języka Java. Łatwo jest napisać własny.

Inne odpowiedzi są w porządku, ale tutaj jest jedna z kilkoma cukrami syntaktycznymi dla każdego.

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

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

Ponadto przykład sumowania tablic jest nawet pokazany w specyfikacji języka Java 7 . Przykład pochodzi z rozdziału 10.4 - Dostęp do tablicy .

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

Nie możesz. Inne języki mają do tego metody, takie jak array_sum () w PHP, ale Java nie.

Właśnie..

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

System.out.println(sum);

W Apache Math: jest StatUtils.sum(double[] arr)

Jedyną kwestią, którą dodałbym do poprzednich rozwiązań, jest to, że użyłbym długiej, aby zgromadzić sumę, aby uniknąć przepełnienia wartości.

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

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

Wyjście :

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

Wyjaśnienie :

W programie Java 8możesz dodać koncepcję redukcji.

Przeczytaj wszystko o redukcji

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

IMHO funkcja sumy wydaje się być dobrym rozwiązaniem, aby rozszerzyć klasę Arrays, w której wypełnianie, sortowanie, wyszukiwanie, kopiowanie i równa się na żywo. Istnieje wiele przydatnych metod ukrytych w javadocach, więc podczas przenoszenia Fortrana do javy warto zadać pytanie przed uruchomieniem naszej własnej metody pomocniczej. Przeszukaj ogromny indeks javadoc, szukając słów „sum”, „add” i wszelkich innych słów kluczowych, które przyjdą Ci do głowy. Możesz podejrzewać, że ktoś już to zrobił dla typów pierwotnych int, float, double, Integer, Float, Double? Bez względu na to, jak proste, zawsze dobrze jest to sprawdzić. Utrzymuj kod tak prosty, jak to tylko możliwe i nie wymyślaj na nowo koła.

Osobiście podoba mi się ta metoda. Mój styl kodu jest trochę dziwny.

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

Całkiem łatwy w użyciu w kodzie:

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

Używam tego:

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

Musisz sam skręcić.
Zaczynasz od sumy równej 0. Następnie rozważ dla każdej liczby całkowitej w tablicy, dodaj ją do sumy. Kiedy nie masz liczb całkowitych, masz sumę.

Gdyby nie było liczb całkowitych, suma wynosi 0.

Z tego ćwiczenia można się nauczyć dwóch rzeczy:

Musisz jakoś przejrzeć elementy tablicy - możesz to zrobić za pomocą pętli for lub pętli while. Musisz zapisać wynik sumowania w akumulatorze. W tym celu musisz utworzyć zmienną.

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

Możesz poprawić wygląd swojego kodu w następujący sposób:

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

To zależy. Ile liczb dodajesz? Testowanie wielu z powyższych sugestii:

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

Zauważyłem, że używając 8-rdzeniowego, 16G Ubuntu18 maszyny, pętla była najszybsza dla mniejszych wartości, a równoległa dla większych. Ale oczywiście zależy to od używanego sprzętu:

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

W bibliotece podkreślenia-java znajduje się metoda sum () .

Przykład kodu:

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

Użyj poniższej logiki:

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

Nie ma na to „metody na lekcjach matematyki”. To nie jest funkcja pierwiastka kwadratowego lub coś w tym rodzaju.

Wystarczy mieć zmienną dla sumy i przejrzeć tablicę, dodając każdą znalezioną wartość do sumy.

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

Możemy korzystać z funkcji zdefiniowanych przez użytkownika. Przy pierwszej inicjalizacji zmiennej sumarycznej równej zero. Następnie przejdź przez tablicę i dodaj element z sumą. Następnie zaktualizuj zmienną sumy.

Fragment kodu:

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

Nieco zaskoczony, że żadna z powyższych odpowiedzi nie uważa, że ​​może być wielokrotnie szybszy przy użyciu puli wątków. W tym przypadku parallelużywa puli wątków łączenia rozwidlonego i automatycznie przerywa strumień na wiele części i uruchamia je równolegle, a następnie łączy. Jeśli tylko pamiętasz następujący wiersz kodu, możesz go używać w wielu miejscach.

Nagroda za najszybszy, krótki i przyjemny kod otrzymuje więc -

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

Powiedzmy, że chcesz to zrobić sum of squares, a następnie Arrays.stream (nums) .parallel (). Map (x-> x * x) .reduce (0, (a, b) -> a + b). Pomysł jest taki, że nadal możesz wykonywać redukcję, bez mapy.

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

    }

}

Od wersji Java 8 Użycie wyrażeń lambda stało się dostępne.

Zobacz:

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

Kompaktowy:

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

Woleć:

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

Zwróć lub wydrukuj sumę.