คุณจะหาผลรวมของตัวเลขทั้งหมดในอาร์เรย์ใน Java ได้อย่างไร

ฉันมีปัญหาในการหาผลรวมของจำนวนเต็มทั้งหมดในอาร์เรย์ใน Java ฉันไม่พบวิธีที่มีประโยชน์ในMathชั้นเรียนสำหรับสิ่งนี้

ใน Java-8 คุณสามารถใช้สตรีม:

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

เอาท์พุท:

ผลรวมคือ 150

มันอยู่ในแพ็คเกจ java.util.stream

import java.util.stream.*;

หากคุณใช้ Java 8 Arraysคลาสจะมีstream(int[] array)วิธีการส่งคืนลำดับตามIntStreamด้วยintอาร์เรย์ที่ระบุ มันยังได้รับการโอเวอร์โหลดdoubleและlongอาร์เรย์

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

นอกจากนี้ยังมีวิธีการ stream(int[] array, int startInclusive, int endExclusive)ที่อนุญาตให้คุณใช้ช่วงของอาร์เรย์ที่ระบุ (ซึ่งมีประโยชน์):

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

Tในที่สุดก็สามารถใช้อาร์เรย์ของพิมพ์ ดังนั้นคุณสามารถมีตัวอย่างStringซึ่งมีตัวเลขเป็นอินพุตและถ้าคุณต้องการหาผลรวมพวกมันทำได้:

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

นี่เป็นหนึ่งในสิ่งง่าย ๆ ที่ไม่มี (AFAIK) ใน Java API มาตรฐาน มันง่ายพอที่จะเขียนของคุณเอง

คำตอบอื่น ๆ นั้นใช้ได้อย่างสมบูรณ์แบบ แต่นี่เป็นคำตอบเดียวสำหรับน้ำตาลแต่ละประโยค

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

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

นอกจากนี้ยังมีตัวอย่างของอาร์เรย์บวกแม้จะถูกแสดงใน Java 7 ข้อมูลจำเพาะทางภาษา ตัวอย่างจากมาตรา 10.4 - อะเรย์การเข้าถึง

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

คุณทำไม่ได้ ภาษาอื่นมีวิธีการบางอย่างเช่น array_sum () ใน PHP แต่ Java ไม่มี

แค่..

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

System.out.println(sum);

ใน Apache Math: มี StatUtils.sum(double[] arr)

จุดเดียวที่ฉันจะเพิ่มไปยังโซลูชันก่อนหน้าคือฉันจะใช้เวลานานเพื่อสะสมผลรวมเพื่อหลีกเลี่ยงการล้นของมูลค่าใด ๆ

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

ใน Java 8

รหัส :

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

ผลผลิต :

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

คำอธิบาย :

ในJava 8คุณสามารถใช้แนวคิดการลดเพื่อเพิ่มของคุณ

อ่านทั้งหมดเกี่ยวกับการลด

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

IMHO ฟังก์ชั่นผลรวมจะดูเหมือนดีที่จะขยายชั้นเรียนอาร์เรย์ที่เติมเรียงลำดับค้นหาคัดลอกและเท่ากับอยู่ มีวิธีที่มีประโยชน์มากมายซ่อนตัวอยู่ใน javadocs ดังนั้นจึงเป็นคำถามที่ยุติธรรมเมื่อทำการพอร์ต Fortran ไปยังจาวาเพื่อถามก่อนที่จะกลิ้งวิธีการช่วยเหลือของเราเอง ค้นหาดัชนี javadoc ขนาดใหญ่สำหรับ "ผลรวม", "เพิ่ม" และคำหลักอื่น ๆ ที่คุณอาจนึกถึง คุณอาจสงสัยว่ามีคนทำสิ่งนี้แล้วสำหรับประเภทดั้งเดิม int, float, double, Integer, Float, Double? ไม่ว่าจะเรียบง่ายแค่ไหนก็ควรตรวจสอบอยู่เสมอ รักษารหัสให้ง่ายที่สุดเท่าที่จะเป็นไปได้และอย่าหมุนพวงมาลัยใหม่

ฉันชอบวิธีนี้เป็นการส่วนตัว สไตล์โค้ดของฉันแปลกไปหน่อย

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

สวยใช้งานง่ายในรหัส:

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

ฉันใช้สิ่งนี้:

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

คุณต้องม้วนตัวเอง
คุณเริ่มต้นด้วยผลรวมเป็น 0 จากนั้นพิจารณาจำนวนเต็มทุกตัวในอาร์เรย์เพิ่มเป็นผลรวม จากนั้นเมื่อคุณไม่มีจำนวนเต็มคุณจะได้ผลรวม

หากไม่มีจำนวนเต็มจำนวนรวมจะเป็น 0

มีสองสิ่งที่ต้องเรียนรู้จากแบบฝึกหัดนี้:

คุณจำเป็นต้องวนซ้ำองค์ประกอบต่างๆของอาเรย์อย่างใดอย่างหนึ่ง - คุณสามารถทำสิ่งนี้ได้ด้วยการวนรอบหรือวนรอบสักครู่ คุณต้องเก็บผลลัพธ์ของการรวมไว้ในตัวสะสม สำหรับสิ่งนี้คุณต้องสร้างตัวแปร

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

คุณสามารถทำให้โค้ดของคุณดูดีขึ้นเช่นนี้:

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

มันขึ้นอยู่กับ. คุณเพิ่มตัวเลขกี่ตัว? ทดสอบคำแนะนำข้างต้นหลายข้อ:

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 core, เครื่อง 16 G Ubuntu18, การวนรอบนั้นเร็วที่สุดสำหรับค่าที่น้อยกว่าและการขนานขนาดใหญ่ขึ้น แต่แน่นอนมันขึ้นอยู่กับฮาร์ดแวร์ที่คุณใช้:

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

มีเมธอด sum () ในไลบรารีขีดล่าง - จาวา

ตัวอย่างรหัส:

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

ใช้ตรรกะด้านล่าง:

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

ไม่มี 'วิธีการในชั้นเรียนคณิตศาสตร์' สำหรับสิ่งนั้น มันไม่เหมือนกับฟังก์ชันสแควร์รูทหรืออะไรทำนองนั้น

คุณเพียงแค่ต้องมีตัวแปรสำหรับผลรวมและวนรอบอาร์เรย์ที่เพิ่มค่าแต่ละค่าที่คุณพบในผลรวม

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

เราอาจใช้ฟังก์ชั่นที่ผู้ใช้กำหนด ในตอนแรกเริ่มต้นรวมตัวแปรเท่ากับศูนย์ จากนั้นสำรวจอาร์เรย์และเพิ่มองค์ประกอบด้วยผลรวม จากนั้นอัพเดตตัวแปรผลรวม

ตัวอย่างโค้ด:

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

ประหลาดใจเล็กน้อยที่เห็นว่าไม่มีคำตอบใด ๆ ข้างต้นพิจารณาแล้วว่าสามารถทำได้เร็วขึ้นหลายเท่าโดยใช้กลุ่มเธรด ที่นี่parallelใช้กลุ่มเธรดแยกร่วมและแบ่งกระแสโดยอัตโนมัติในหลายส่วนและเรียกใช้ขนานและผสาน หากคุณจำรหัสบรรทัดต่อไปนี้ได้คุณสามารถใช้งานได้หลายที่

ดังนั้นรางวัลสำหรับรหัสย่อที่สั้นและเร็วที่สุดจึงเป็น -

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

ให้บอกว่าคุณต้องการทำsum of squaresแล้วตามด้วย Arrays.stream (ตัวเลข) .parallel (). map (x-> x * x) .reduce (0, (a, b) -> a + b) แนวคิดคือคุณยังคงสามารถลดได้โดยไม่ต้องใช้แผนที่

 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 การใช้แลมบ์ดานิพจน์นั้นมีอยู่

ดูนี่:

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

ขนาดกะทัดรัด:

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

ต้องการ:

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

ส่งคืนหรือพิมพ์ผลรวม