**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(n*^{2}).

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) {
addPairs(input[i], sum-input[i]));
}
}
}
```

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)
.forEach(j -> addPairs(input[i], input[j]))
);
```

**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) {
addPairs(i, sum-i);
}
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) {
addPairs(input[i], sum - input[i]);
}
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.

res – REST with Spring (eBook) (everywhere)