高效利用Java 8 Stream API查找数组中特定和的元素对

import java.util.List;

public class ArraySumFinder {

    /**
     * 使用嵌套循环查找数组中是否存在两个数之和等于目标值。
     * 时间复杂度：O(n^2)
     * @param targetSum 目标和
     * @param array 整数列表
     * @return 如果存在则返回 true，否则返回 false
     */
    public static boolean findPairBruteForce(int targetSum, List<Integer> array) {
        for (int i = 0; i < array.size() - 1; i++) {
            for (int j = i + 1; j < array.size(); j++) {
                if (array.get(i) + array.get(j) == targetSum) {
                    return true;
                }
            }
        }
        return false;
    }

    public static void main(String[] args) {
        List<Integer> arrayOne = List.of(1, 3, 6, 9);
        List<Integer> arrayTwo = List.of(1, 6, 2, 10);

        System.out.println("Brute force for arrayOne (target 8): " + findPairBruteForce(8, arrayOne)); // false
        System.out.println("Brute force for arrayTwo (target 8): " + findPairBruteForce(8, arrayTwo)); // true
    }
}

import java.util.List;
import java.util.Set;
import java.util.HashSet;

public class ArraySumFinderOptimized {

    /**
     * 使用 Set 优化查找数组中是否存在两个数之和等于目标值。
     * 时间复杂度：O(n)，空间复杂度：O(n)
     * @param targetSum 目标和
     * @param array 整数列表
     * @return 如果存在则返回 true，否则返回 false
     */
    public static boolean findPairOptimized(int targetSum, List<Integer> array) {
        Set<Integer> seenNumbers = new HashSet<>();
        for (Integer num : array) {
            int complement = targetSum - num;
            // 检查补数是否已存在于 seenNumbers 中，并且补数不能是当前数字本身
            // 除非 targetSum 是当前数字的两倍，且列表中确实有两个相同的数字（此方案默认数字不重复）
            if (seenNumbers.contains(complement) && (targetSum != 2 * num || seenNumbers.contains(num))) {
                System.out.printf("找到 %d + %d = %d%n", complement, num, targetSum);
                return true;
            }
            seenNumbers.add(num);
        }
        System.out.printf("未找到两个数之和为 %d%n", targetSum);
        return false;
    }

    public static void main(String[] args) {
        List<Integer> arrayOne = List.of(1, 3, 6, 9);
        List<Integer> arrayTwo = List.of(1, 6, 2, 10);
        List<Integer> arrayThree = List.of(4, 4, 1, 7); // 示例，如果允许重复数字，但Set会去重
        List<Integer> arrayFour = List.of(4, 1, 7); // 示例，target 8

        System.out.println("\nOptimized for arrayOne (target 8):");
        System.out.println(findPairOptimized(8, arrayOne)); // false

        System.out.println("\nOptimized for arrayTwo (target 8):");
        System.out.println(findPairOptimized(8, arrayTwo)); // true

        System.out.println("\nOptimized for arrayFour (target 8):");
        System.out.println(findPairOptimized(8, arrayFour)); // true (4+4，但Set去重后无法找到)

        // 注意：如果输入列表可能包含重复数字，且允许使用相同的数字两次（例如 [4,4] target 8），
        // 那么 `seenNumbers.contains(complement) && (targetSum != 2 * num || seenNumbers.contains(num))`
        // 这种判断需要根据具体业务需求调整。
        // 如果 Set 存储的是原始列表，且允许重复，则需要使用其他数据结构或额外的计数。
        // 在本教程的上下文中，我们假设寻找的是两个不同的数字，或者如果数字相同，它们必须是列表中的两个不同实例。
        // 如果 Set 是从原始列表直接创建的 `Set.copyOf(array)`，那么它只包含唯一元素。
    }
}

import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

public class ArraySumFinderWithStreams {

    /**
     * 使用 Stream API 查找数组中是否存在两个数之和等于目标值，并打印结果。
     * 时间复杂度：O(n)，空间复杂度：O(n)
     * @param targetSum 目标和
     * @param array 整数列表
     * @return 如果存在则返回 true，否则返回 false
     */
    public static boolean findPairStreamWithLogging(int targetSum, List<Integer> array) {
        // 将列表转换为 Set，以便进行 O(1) 查找。
        // 注意：Set.copyOf(array) 会创建一个不可变 Set，如果 array 很大，此操作有 O(n) 成本。
        Set<Integer> uniqueNumbers = Set.copyOf(array);

        return array.stream()
            // 过滤条件：
            // 1. 补数存在于 uniqueNumbers 中。
            // 2. 避免同一个数字被自身作为补数使用（除非目标和是该数字的两倍，且列表中确实有两个该数字的实例，
            //    但由于 uniqueNumbers 是去重的，此处的 `targetSum != 2 * num` 确保了不使用同一个元素两次）。
            .filter(num -> uniqueNumbers.contains(targetSum - num) && (targetSum != 2 * num))
            .findFirst() // 找到第一个符合条件的元素
            .map(num -> { // 如果找到了，执行打印并返回 true
                System.out.printf("找到 %d + %d = %d%n", num, targetSum - num, targetSum);
                return true;
            })
            .orElseGet(() -> { // 如果未找到，执行打印并返回 false
                System.out.printf("未找到两个数之和为 %d%n", targetSum);
                return false;
            });
    }

    /**
     * 最简化的 Stream API 方法，仅返回布尔结果。
     * @param targetSum 目标和
     * @param array 整数列表
     * @return 如果存在则返回 true，否则返回 false
     */
    public static boolean findPairStreamSimplified(int targetSum, List<Integer> array) {
        Set<Integer> uniqueNumbers = Set.copyOf(array);
        return array.stream()
            .anyMatch(num -> uniqueNumbers.contains(targetSum - num) && (targetSum != 2 * num));
    }

    public static void main(String[] args) {
        List<Integer> arrayOne = List.of(1, 3, 6, 9);
        List<Integer> arrayTwo = List.of(1, 6, 2, 10);
        List<Integer> arrayFour = List.of(4, 1, 7); // target 8

        System.out.println("\nStream with logging for arrayOne (target 8):");
        System.out.println(findPairStreamWithLogging(8, arrayOne)); // false

        System.out.println("\nStream with logging for arrayTwo (target 8):");
        System.out.println(findPairStreamWithLogging(8, arrayTwo)); // true

        System.out.println("\nStream with logging for arrayFour (target 8):");
        System.out.println(findPairStreamWithLogging(8, arrayFour)); // true

        System.out.println("\nStream simplified for arrayOne (target 8): " + findPairStreamSimplified(8, arrayOne)); // false
        System.out.println("Stream simplified for arrayTwo (target 8): " + findPairStreamSimplified(8, arrayTwo)); // true
    }
}