Java 8 Stream API：高效查找数组中两数之和

import java.util.List;

public class TwoSumFinder {

    /**
     * 使用嵌套循环查找数组中是否存在两个数之和等于目标值。
     * 时间复杂度：O(n^2)
     *
     * @param target 目标和
     * @param array  整数列表
     * @return 如果找到则返回 true，否则返回 false
     */
    public static boolean validateArrayTraditional(int target, List<Integer> array) {
        for (int i = 0; i < array.size() - 1; i++) {
            for (int j = i + 1; j < array.size(); j++) {
                int value1 = array.get(i);
                int value2 = array.get(j);
                if (value1 + value2 == target) {
                    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("传统方法 - arrayOne (8): " + validateArrayTraditional(8, arrayOne)); // false
        System.out.println("传统方法 - arrayTwo (8): " + validateArrayTraditional(8, arrayTwo)); // true
    }
}

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

public class TwoSumFinderOptimized {

    /**
     * 使用 Set 优化查找数组中是否存在两个数之和等于目标值。
     * 时间复杂度：O(n)
     *
     * @param target 目标和
     * @param array  整数列表
     * @return 如果找到则返回 true，否则返回 false
     */
    public static boolean validateArrayOptimized(int target, List<Integer> array) {
        // 将列表转换为 Set，以便进行 O(1) 查找。
        // 使用 Set.copyOf(array) 可以创建一个不可变的 Set，或者使用 new HashSet<>(array)
        Set<Integer> set = new HashSet<>(array); 

        for (Integer num : array) {
            int complement = target - num;
            // 检查补数是否存在于 Set 中
            // 并且确保不是同一个数字自身相加（除非目标值是 num 的两倍且 num 在列表中出现多次）
            // 这里的 (target != 2 * num) 确保了如果列表中只有一个 '4'，
            // 目标是 '8' 时不会误判 '4 + 4' 为真。
            if (set.contains(complement) && (target != 2 * num)) {
                System.out.printf("找到 %s + %s = %s%n", num, complement, target);
                return true;
            }
        }
        System.out.printf("未找到两个数之和等于 %s%n", target);
        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("\n优化方法 - arrayOne (8): " + validateArrayOptimized(8, arrayOne)); // false
        System.out.println("优化方法 - arrayTwo (8): " + validateArrayOptimized(8, arrayTwo)); // true
    }
}

import java.util.List;
import java.util.Set;
import java.util.stream.Collectors; // For Set.copyOf or new HashSet

public class TwoSumFinderStream {

    /**
     * 使用 Stream API 查找数组中是否存在两个数之和等于目标值（带日志输出）。
     * 时间复杂度：O(n)
     *
     * @param target 目标和
     * @param array  整数列表
     * @return 如果找到则返回 true，否则返回 false
     */
    public static boolean validateArrayStreamWithLogging(int target, List<Integer> array) {
        // 将列表转换为 Set，以便进行 O(1) 查找。
        // 使用 Set.copyOf(array) 创建一个不可变 Set 是一个好习惯。
        Set<Integer> set = Set.copyOf(array);

        return array.stream()
            // 过滤出满足条件的数字：其补数存在于 Set 中，且不是同一个数字自身相加
            .filter(num -> set.contains(target - num) && (target != 2 * num))
            // 找到第一个满足条件的数字
            .findFirst()
            // 如果找到了，执行日志输出并返回 true
            .map(num -> {
                System.out.printf("Stream API (带日志) - 找到 %s + %s = %s%n", num, target - num, target);
                return true;
            })
            // 如果未找到，执行日志输出并返回 false
            .orElseGet(() -> {
                System.out.printf("Stream API (带日志) - 未找到两个数之和等于 %s%n", target);
                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("\n--- Stream API (带日志) ---");
        System.out.println("arrayOne (8): " + validateArrayStreamWithLogging(8, arrayOne));
        System.out.println("arrayTwo (8): " + validateArrayStreamWithLogging(8, arrayTwo));
    }
}

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

public class TwoSumFinderStreamConcise {

    /**
     * 使用 Stream API 查找数组中是否存在两个数之和等于目标值（仅返回布尔结果）。
     * 时间复杂度：O(n)
     *
     * @param target 目标和
     * @param array  整数列表
     * @return 如果找到则返回 true，否则返回 false
     */
    public static boolean validateArrayStreamConcise(int target, List<Integer> array) {
        Set<Integer> set = Set.copyOf(array); // 创建不可变 Set

        return array.stream()
                // 使用 anyMatch 检查是否存在任何一个元素满足条件
                .anyMatch(num -> set.contains(target - num) && (target != 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);

        System.out.println("\n--- Stream API (仅返回布尔结果) ---");
        System.out.println("arrayOne (8): " + validateArrayStreamConcise(8, arrayOne)); // false
        System.out.println("arrayTwo (8): " + validateArrayStreamConcise(8, arrayTwo)); // true
    }
}