In this article, we will explore how to write a Java program to find the sum of elements in an array.
What is Arrays Elements in Java Program?
Arrays are fundamental data structures in programming that allow us to store multiple elements of the same data type in a single container. They play a crucial role in various programming tasks, and moreover, one common operation is to calculate the sum of array elements.
Methods to Find the Sum of Array Elements
1. Using a while loop
2. Using For loop
3. Using functions
Using while loop
// Java Program to Find Sum of Array Elements
import java.util.Scanner;
public class SumOfArrayEx {
private static Scanner sc;
public static void main(String[] args)
{
int Size, i = 0, j = 0, total = 0;
sc = new Scanner(System.in);
System.out.print("Enter Number of elements : ");
Size = sc.nextInt();
int [] a = new int[Size];
System.out.print(" Please Enter " + Size + " elements : ");
while(i < Size)
{
a[i] = sc.nextInt();
i++;
}
while(j < Size)
{
total = total + a[j];
j++;
}
System.out.println("\n The Sum of All the Elements in this Array = " + total);
}
}
Explanation of Code:
1. Import the required Scanner class for input.
2. Define a class named `SumOfArrayEx`.
3. To facilitate input, declare a private static ‘Scanner’ object named ‘sc’.
4. Define the `main` method.
5. Initialize variables `Size` (for array size), `i` (for array index), `j` (for loop iteration), and `total` (for accumulating the sum of array elements).
6. Ask the user to enter the number of elements (`Size`) in the array.
7. Create an integer array `a` of size `Size` to store the user-input elements.
8. Ask the user to input each element of the array. The loop continues until `i` is less than `Size`. The input elements are stored in the array `a`.
9. Calculate the sum of array elements using another loop. The loop continues until `j` is less than `Size`. The element at index `j` in array `a` is added to the `total`.
10. Finally, display the sum of all elements in the array using the `System.out.println` statement.
Algorithm:
1. Firstly initialize variables `Size`, `i`, `j`, and `total`.
2. Read the value of `Size` (number of elements in the array) from the user.
3. Create an integer array `a` of size `Size`.
4. Read `Size` number of elements from the user and then store them in the array `a`.
5. Initialize `j` to 0 and start a loop to iterate through the array elements.
6. In each iteration, add the element at index `j` in array `a` to the `total`.
7. Increment `j` to move to the next element.
8. After the loop, display the `total`, which represents the sum of all elements in the array.
Output:
Enter Number of elements : 7
Please Enter 7 elements : 14
47
58
98
93
54
64
The Sum of All the Elements in this Array = 428Learn How to Sort an Array in Java, Here!
Using For Loop
// Java Program to Find Sum of Array Elements
import java.util.Scanner;
public class SumOfElementsEx {
private static Scanner sc;
public static void main(String[] args)
{
int Size, i, total = 0;
sc = new Scanner(System.in);
System.out.print(" Please Enter Number of elements in an array : ");
Size = sc.nextInt();
int [] a = new int[Size];
System.out.print(" Please Enter " + Size + " elements of an Array : ");
for (i = 0; i < Size; i++)
{
a[i] = sc.nextInt();
}
for(i = 0; i < Size; i++)
{
total = total + a[i];
}
System.out.println("\n The Sum of All Elements in this Array = " + total);
}
}
Method Used to Find the Sum of Array Elements:
The method used to find the sum of array elements in this program involves iterating through the array using a `for` loop, moreover accumulating the sum in the variable `total`.
Explanation of the Code:
1. The program starts by importing the `java.util.Scanner` class for user input.
2. The ‘main’ method is defined, consequently serving as the entry point of the program.
3. Inside the `main` method:
– A `Scanner` object named `sc` is declared to read input from the user.
– Variables `Size`, `i`, and `total` are declared. `Size` will store the number of elements in the array, `i` is used for looping, and `total` will store the sum of array elements.
4. The program prompts the user to enter the number of elements in the array using `System.out.print` and then reads the input using `sc.nextInt()`.
5. An integer array `a` of size `Size` is declared to store the elements of the array.
6. The program prompts the user to enter the elements of the array using a `for` loop. The loop runs from 0 to `Size – 1` and then reads the elements one by one using `sc.nextInt()`.
7. Another `for` loop is used to iterate through the elements of the array and calculate the sum. The sum is updated in the `total` variable.
8. Finally, the program prints the calculated sum using `System.out.println`.
Algorithm:
1. Firstly import the required `java.util.Scanner` class.
2. Declare the `main` method.
3. Create a `Scanner` object named `sc`.
4. Declare `Size`, `i`, and `total` variables.
5. Prompt the user to enter the number of elements, and subsequently read the input into `Size`.
6. Declare an integer array `a` of size `Size`.
7. Prompt the user to enter the elements of the array using a loop.
8. Iterate through the array elements using a loop and then calculate the sum.
9. Finally print the calculated sum.
Output:
Please Enter Number of elements in an array : 4
Please Enter 4 elements of an Array: 65
7
6
5
The Sum of All Elements in this Array = 83Using functions
// Java Program to Find Sum of Array Elements
import java.util.Scanner;
public class SumOfArrayEx {
private static Scanner sc;
public static void main(String[] args)
{
int Size, i, Sm = 0;
sc = new Scanner(System.in);
System.out.print(" Please Enter Number of elements : ");
Size = sc.nextInt();
int [] a = new int[Size];
System.out.print(" Please Enter " + Size + " elements : ");
for (i = 0; i < Size; i++)
{
a[i] = sc.nextInt();
}
Sm = SmOfArr(a, Size);
System.out.println("\n The Sum of All Elements in this Array = " + Sm);
}
public static int SmOfArr(int[] a, int Size)
{
int i, Sm = 0;
for(i = 0; i < Size; i++)
{
Sm = Sm + a[i];
}
return Sm;
}
}
Get a Complete list of Online Certification Courses in India here!
Method Used to Find the Sum of Array Elements:
The method used to find the sum of array elements in the provided Java code is called `SmOfArr`. This method takes two parameters: an integer array ‘a’ and, specifically, an integer ‘Size’, which represents the number of elements in the array. The method iterates through the array using a loop and accumulates the sum of all elements, which is then returned as the result.
Explanation of the Code:
1. Import Statements: The code begins with an import statement that brings in the `Scanner` class from the `java.util` package.
2. Main Method (`main`):
– It initializes the `Scanner` object `sc` to read input from the console.
– The user is prompted to enter the number of elements (`Size`) they want to input.
– An integer array `a` of size `Size` is created.
– The user is then prompted to input each element of the array.
– The input values are stored in the array `a`.
3. Calling the `SmOfArr` Method:
– After inputting the array elements, the `SmOfArr` method is called with the array `a` and also the size `Size` as arguments.
– The returned sum is stored in the variable `Sm`.
4. The `SmOfArr` Method:
– This method takes the integer array `a` and the integer `Size` as parameters.
– It iterates through the array using a loop and then adds each element’s value to the variable `Sm`, which holds the sum.
– The method then returns the calculated sum.
5. Printing the Result:
– Finally, the main method prints out the sum of all elements in the array.
Algorithm:
1. Firstly import the `Scanner` class from the `java.util` package.
2. Initialize the `Scanner` object to read input.
3. Prompt the user to enter the number of elements (`Size`) for the array.
4. Create an integer array `a` of size `Size`.
5. Prompt the user to input each element of the array and then store them in the array.
6. Call the `SmOfArr` method with the array `a` and `Size` as arguments.
7. In the `SmOfArr` method:
– Iterate through the array using a loop.
– Add each element’s value to the `Sm` variable.
– Return the calculated sum.
8. Finally print the calculated sum in the main method.
Output:
Please Enter Number of elements : 2
Please Enter 2 elements : 123
143
The Sum of All Elements in this Array = 266Tips and tricks to find the sum of array elements
10 tips and tricks to help you find the sum of array elements efficiently in Java:
1. Use Enhanced For Loop (for each):
The enhanced for loop simplifies array traversal and, furthermore, sum calculation.
int sum = 0;
for (int num : array) {
sum += num;
}
2. Precompute Cumulative Sums:
Calculate cumulative sums beforehand to find the sum of a subarray efficiently.
int[] cumSum = new int[array.length];
cumSum[0] = array[0];
for (int i = 1; i < array.length; i++) {
cumSum[i] = cumSum[i - 1] + array[i];
}
int sum = cumSum[endIndex] - cumSum[startIndex - 1];
3. Divide and Conquer:
Utilize a divide-and-conquer approach to initially split the array, and subsequently, compute sums recursively.
4. Parallel Processing:
Leverage Java’s parallel processing capabilities using streams for efficient sum calculation.
int sum = Arrays.stream(array).parallel().sum();
5. Bit Manipulation:
Utilize bit manipulation to calculate the sum without arithmetic operators.
int sum = 0;
for (int num : array) {
sum ^= num;
}
6. Using Arrays.stream() with Reduce:
Use `Arrays.stream()` with `reduce` to find the sum.
int sum = Arrays.stream(array).reduce(0, (a, b) -> a + b);
7. Optimized Loops:
Optimize traditional loops by either unrolling or vectorizing to significantly improve computation speed.
8. Use Math Library:
Utilize Java’s Math library to handle array sums.
int sum = 0;
for (int num : array) {
sum = Math.addExact(sum, num);
}
Learn How to Generate Random Numbers in Python, Now!
9. Bitwise Shifts:
Use bitwise left shift for multiplication-based summation algorithms.
int sum = 0;
for (int num : array) {
sum += num;
}
sum = (sum >> 1) + (sum & 1);
10. Parallel Array Summation:
Divide the array into segments and calculate sums in parallel, then combine the results.
int numThreads = Runtime.getRuntime().availableProcessors();
int segmentSize = array.length / numThreads;
ExecutorService executor = Executors.newFixedThreadPool(numThreads);
List<Future<Integer>> results = new ArrayList<>();
for (int i = 0; i < numThreads; i++) {
int startIndex = i * segmentSize;
int endIndex = (i == numThreads - 1) ? array.length - 1 : (startIndex + segmentSize - 1);
results.add(executor.submit(new ArraySumTask(array, startIndex, endIndex)));
}
int sum = 0;
for (Future<Integer> result : results) {
sum += result.get();
}
executor.shutdown();
Efficiently finding the sum of array elements involves a combination of optimizing loops, leveraging built-in Java features, and employing mathematical techniques.
In conclusion, mastering the art of efficiently finding the sum of array elements in Java is a crucial skill for programmers. This blog delved into the essence of array elements, then explored various methods to discover the largest number, and unveiled an array of tips and tricks. From leveraging parallel processing to bitwise manipulations, these techniques empower developers to navigate arrays with precision, enabling them to write more performant and optimized code.
Our blog post on ‘Java Program to Find Sum of Array Elements’ aims to offer valuable information. For more programming related Blogs and Courses visit our official website Newtum to make your learning easy!
About The Author
