Find which number in a list sum up to a certain number Using Java 8 Stream API

I have tried to find the sum of pair which is equals to given number using java 8. how can we improve the logic?

List<Integer> listOfNumbers = Arrays.asList(new Integer []{15, 12, 4, 16, 9, 8, 24, 0});

	Set<Integer[]> sumPair = listOfNumbers.stream()
			.flatMap(i -> listOfNumbers.stream()
					.filter(p -> (i + p) == 16 && listOfNumbers.indexOf(p) != listOfNumbers.indexOf(i))
					.map(p -> new Integer[] { i, p }))
			.collect(Collectors.toSet());
	for (Integer[] integers : sumPair) {
		for (Integer val : integers) {
			System.out.print(val + " ");
		}
		   System.out.println("");
	}

Expected output:

16 0 
12 4 

Output I am getting:

16 0 
4 12 
0 16 
12 4  

    static void printPairs(List<Integer> list, int sum){
        list
            .stream()
            .flatMap(i -> list.stream().filter(j -> i + j == sum && i < j))
            .map(k -> k + ", " + (sum-k))
            .distinct()
            .forEach(System.out::println);
    }

It seems, you just need to SORT the pair. The pairs are duplicated just because of the reverse order of the numbers in the pair.

		List<Integer> listOfNumbers = Arrays.asList(15, 12, 4, 16, 9, 8, 24, 0);
		Set<String> sumPair = listOfNumbers.stream()
				.flatMap(i -> listOfNumbers.stream()
						.filter(p -> (i + p) == 16 && listOfNumbers.indexOf(p) != listOfNumbers.indexOf(i))
						.map(p -> i < p ? (p + " " + i) : (i + " " + p)))
				.collect(Collectors.toSet());
		for (String pair : sumPair) {
			System.out.println(pair);
		}

Output:

12 4
16 0

Also, I simplified to use the stream of strings instead of Integer array.
But you can tweak it as you like.

The main problem was "12 4" and "4 12" - the pair of same numbers but in reverse order will be different values for Set, and will get added twice.

Update...
One more thing that can be done is using Stream.distinct, instead of using a Set.

List<Integer> listOfNumbers = Arrays.asList(15, 12, 4, 16, 9, 8, 24, 0, 12);
listOfNumbers.stream()
		.flatMap(i -> listOfNumbers.stream().filter(j -> (i + j) == 16 && i < j).map(k -> i + " " + k))
		.distinct().forEach(System.out::println);

This gives the same output

12 4
16 0

You can take advantage of the fact that 2 sets are considered equal, if they contain the same element, regardless of the order. From the docs:

> Returns true if the specified object is also a set, the two sets have the same size, and every member of the specified set is contained in this set (or equivalently, every member of this set is contained in the specified set).

Collect to a Set<Set<Integer>>

List<Integer> listOfNumbers = Arrays.asList(15, 12, 4, 16, 9, 8, 24, 0);
Set<Set<Integer>> sumPair = listOfNumbers.stream()
        .flatMap(i -> listOfNumbers.stream()
                .filter(p -> (i + p) == 16 && listOfNumbers.indexOf(p) != listOfNumbers.indexOf(i))
                .map(p -> new HashSet<>(Arrays.asList(p, i))))
        .collect(Collectors.toSet());
for (Set<Integer> integers : sumPair) {
  for (Integer val : integers) {
    System.out.print(val + " ");
  }
  System.out.println();
}

Note that HashSet is unordered, so you may need to sort, if it matters.

Personally i would do it with a custom class, though. Let's say Pair:

public class Pair {

  private final int a;
  private final int b;

  public Pair(int a, int b) {
    this.a = a;
    this.b = b;
  }

  @Override
  public int hashCode() {
    return Integer.hashCode(this.a + this.b);
  }

  @Override
  public boolean equals(Object obj) {
    if (this == obj) {
      return true;
    }
    if (!(obj instanceof Pair pair)) {
      return false;
    }
    return (this.a == pair.a && this.b == pair.b) || (this.a == pair.b && this.b == pair.a);
  }

  @Override
  public String toString() {
    return this.a + " " + this.b;
  }
}

Then finding and collecting the pairs would be like this:

List<Integer> listOfNumbers = Arrays.asList(15, 12, 4, 16, 9, 8, 24, 0);
Set<Pair> sumPair = listOfNumbers.stream()
        .flatMap(i -> listOfNumbers.stream()
                .filter(p -> (i + p) == 16 && listOfNumbers.indexOf(p) != listOfNumbers.indexOf(i))
                .map(p -> new Pair(i, p)))
        .collect(Collectors.toSet());
for (Pair pair : sumPair) {
  System.out.println(pair);
}

Your current logic to find pairs whose sum equals a given number is functional, but it has some inefficiencies and redundant pairs in the output. To improve the logic, you can avoid redundant pairs and improve the performance. Here's an optimized version:

public class Main {
    public static void main(String[] args) {
        List<Integer> listOfNumbers = Arrays.asList(new Integer[]{15, 12, 4, 16, 9, 8, 24, 0});
        int targetSum = 16;

        Set<Integer[]> sumPair = findPairsWithSum(listOfNumbers, targetSum);
        for (Integer[] integers : sumPair) {
            for (Integer val : integers) {
                System.out.print(val + " ");
            }
            System.out.println("");
        }
    }

    public static Set<Integer[]> findPairsWithSum(List<Integer> list, int targetSum) {
        Set<Integer> seen = new HashSet<>();
        Set<Integer[]> sumPair = new HashSet<>();

        for (Integer num : list) {
            int complement = targetSum - num;
            if (seen.contains(complement)) {
                Integer[] pair = {num, complement};
                Arrays.sort(pair);
                sumPair.add(pair);
            }
            seen.add(num);
        }
        return sumPair;
    }
}

In this version, we use a HashSet called seen to store the elements of the list that we have encountered so far. As we iterate through the list, we check if the complement (the difference between the targetSum and the current number) is present in the seen set. If it is, we have found a pair that adds up to the targetSum, and we add the pair to the sumPair set. Sorting the pair before adding it ensures that we don't have duplicates like (4, 12) and (12, 4).

This solution reduces the complexity and avoids redundant pairs in the output.