Sum of Two Arrays in Java

Java is a powerful programming language known for its versatility and extensive libraries. When working with arrays, you may often encounter scenarios where you need to calculate the sum of two arrays. Whether you're a beginner or an experienced developer, understanding how to accomplish this task is crucial. In this section, we will explore different approaches to finding the sum of two arrays in Java.

Approach 1: Naive Iteration

The simplest way to find the sum of two arrays is by iterating over each corresponding element and adding them together. Let's assume we have two arrays, array1 and array2, of the same length n. Here's an example implementation using a for loop:

File Name: SumOfTwoArrays.java

public class SumOfTwoArrays {
    public static void main(String[] args) {
        int[] array1 = {1, 2, 3};
        int[] array2 = {4, 5, 6};
        int[] sumArray = new int[array1.length];
        for (int i = 0; i < array1.length; i++) {
            sumArray[i] = array1[i] + array2[i];
        }
        // Printing the sumArray
        System.out.print("Sum Array: ");
        for (int num : sumArray) {
            System.out.print(num + " ");
        }
    }
}

Output:

Sum Array: 5 7 9

This approach has a time complexity of O(n), where n is the length of the arrays. It provides a straightforward solution but assumes that both arrays have the same length.

Approach 2: Handling Arrays with Different Lengths

In some cases, the arrays may have different lengths, and you'll need to account for this while finding the sum. One way to handle this situation is by finding the maximum length among the two arrays and iterating up to that length. For elements beyond the smaller array's length, we can assume them to be zero. Here's an implementation that handles arrays with different lengths:

File Name: SumOfTwoArrays.java

public class SumOfTwoArrays {
    public static void main(String[] args) {
        int[] array1 = {1, 2, 3};
        int[] array2 = {4, 5, 6, 7};
        int[] sumArray = new int[Math.max(array1.length, array2.length)];
        for (int i = 0; i < sumArray.length; i++) {
            int num1 = (i < array1.length) ? array1[i] : 0;
            int num2 = (i < array2.length) ? array2[i] : 0;
            sumArray[i] = num1 + num2;
        }
        // Printing the sumArray
        System.out.print("Sum Array: ");
        for (int num : sumArray) {
            System.out.print(num + " ");
        }
    }
}

Output:

Sum Array: 5 7 9 7

This approach handles arrays of different lengths by assuming missing elements as zeros. It also has a time complexity of O(n), where n is the maximum length of the two arrays.

Approach 3: Using Streams (Java 8+)

If you're working with Java 8 or above, you can leverage the power of streams to find the sum of two arrays concisely. The IntStream class provides a sum operation that can be used to calculate the sum of corresponding elements from both arrays. Here's an example implementation:

File Name: SumOfTwoArrays.java

import java.util.Arrays;
import java.util.stream.IntStream;
public class SumOfTwoArrays {
    public static void main(String[] args) {
        int[] array1 = {1, 2, 3};
        int[] array2 = {4, 5, 6};
        int[] sumArray = IntStream.range(0, array1.length)
                                  .map(i -> array1[i] + array2[i])
                                  .toArray();
        // Printing the sumArray
        System.out.print("Sum Array: ");
        Arrays.stream(sumArray).forEach(num -> System.out.print(num + " "));
    }
}

Output:

Sum Array: 5 7 9

The approach utilizes the IntStream and its map operation to add corresponding elements of both arrays. The resulting stream is then converted back into an array using the toArray() method. The time complexity remains O(n), where n is the length of the arrays.

Here are the pros and cons for each approach:

Approach 1: Naive Iteration

Pros:

Simple and easy to understand.
Works well when the arrays have the same length.
Time complexity is O(n), where n is the length of the arrays.

Cons:

Assumes that both arrays have the same length, and may lead to unexpected results if they differ.
Not suitable for handling arrays with different lengths.

Approach 2: Handling Arrays with Different Lengths

Pros:

Handles arrays with different lengths by assuming missing elements as zeros.
Provides correct results even when the arrays have different lengths.
Time complexity is O(n), where n is the maximum length of the two arrays.

Cons:

Requires additional logic to handle arrays of different lengths, which can make the code slightly more complex.
Involves creating a new array with the maximum length, which may consume additional memory if the arrays are significantly different in size.

Approach 3: Using Streams (Java 8+)

Pros:

Concise and expressive code using Java 8's stream API.
Works well with arrays of the same length or different lengths.
No need for explicit iteration or index tracking.
Time complexity is O(n), where n is the length of the arrays.

Cons:

Requires Java 8 or above, limiting compatibility with older versions of Java.
May have a slight performance overhead compared to the previous approaches due to the use of streams.

It's important to consider the specific requirements of your application when choosing the most appropriate approach. If you're dealing with arrays of the same length and prefer simplicity, the naive iteration approach (Approach 1) may be suitable. If you need to handle arrays of different lengths accurately, Approach 2 provides a solution. Approach 3 using streams offers concise code but requires Java 8 or above and may have a slight performance impact.

In conclusion, finding the sum of two arrays in Java can be achieved using different approaches. The choice of approach depends on whether the arrays have the same length or different lengths. By understanding these techniques, you can handle array sums efficiently in your Java programs, regardless of the array sizes.

Next TopicWhat is Is-A-Relationship in Java?

← prev next →