## 1. Overview

In this quick tutorial, we'll show how to implement an algorithm for finding all pairs of numbers in an array whose sum equals a given number. We'll focus on two approaches to the problem.

In the first approach, we'll find all such pairs regardless of uniqueness.Â In the second, we'llÂ find only the unique number combinations, removing redundant pairs.

For each approach, we'll present two implementationsÂ â€” a traditional implementation usingÂ forÂ loops, and a second using the Java 8 Stream API.

## 2. Return All Matching Pairs

We'll iterate through an array of integers, finding all pairs (i andÂ j) that sum up to the given number (sum) using a brute-force, nested-loop approach. This algorithm will have a runtime complexity of O(n2).

For our demonstrations, we'll look for all pairs of numbers whose sum is equal to 6, using the following input array:

``````int[] input = { 2, 4, 3, 3 };
``````

In this approach, our algorithm should return:

``{2,4}, {4,2}, {3,3}, {3,3}``

In each of the algorithms, when we find a target pair of numbers that sum up to the target number, we'll collect the pair using a utility method, addPairs(i, j).

The first way we might think to implement the solution is by using the traditionalÂ forÂ loop:

``````for (int i = 0; i < input.length; i++) {
for (int j = 0; j < input.length; j++) {
if (j != i && (input[i] + input[j]) == sum) {
}
}
}``````

This can be a bit rudimentary, so let's also write an implementation using the Java 8 Stream API.

Here, we use the methodÂ IntStream.rangeÂ to generate a sequential stream of numbers. Then, we filter them for our condition: number 1 + number 2 = sum:

``````IntStream.range(0,  input.length)
.forEach(i -> IntStream.range(0,  input.length)
.filter(j -> i != j && input[i] + input[j] == sum)
);
``````

## 3. Return All Unique Matching Pairs

For this example, we'll have to develop a smarter algorithm that returns only the unique number combinations, omitting redundant pairs.

To achieve this, we'll add every element to a hash map (without sorting), checking first if the pair hasÂ already been shown. If not, we'll retrieve and mark it as shown (set value field as null).

Accordingly, using the same input array as before, and a target sum of 6, our algorithm should return only the different number combinations:

``{2,4}, {3,3}``

If we use a traditionalÂ forÂ loop, we'll have:

``````Map<Integer, Integer> pairs = new HashMap();
for (int i : input) {
if (pairs.containsKey(i)) {
if (pairs.get(i) != null) {
}
pairs.put(sum - i, null);
} else if (!pairs.containsValue(i)) {
pairs.put(sum-i, i);
}
}``````

Note that this implementation improves on the previous complexity, as we use only oneÂ forÂ loop, so we'll have O(n).

Now let's solve the problem using Java 8 and the Stream API:

``````Map<Integer, Integer> pairs = new HashMap();
IntStream.range(0, input.length).forEach(i -> {
if (pairs.containsKey(input[i])) {
if (pairs.get(input[i]) != null) {
}
pairs.put(sum - input[i], null);
} else if (!pairs.containsValue(input[i])) {
pairs.put(sum - input[i], input[i]);
}
});``````

## 4. Conclusion

In this article, we explained several different ways to find all pairs that sum up a given number in Java. We saw two different solutions, each using two Java core methods.

As usual, all the code samples shown in this article can beÂ found on GitHubÂ â€” this is a Maven project, so it should be easy to compile and run it.

### Get started with Spring 5 and Spring Boot 2, through the Learn Spring course:

>> CHECK OUT THE COURSE