本教程探讨如何利用java 8 stream api结合set数据结构，高效解决在整数列表中查找和为特定目标值的两个数的问题。文章将从传统的o(n^2)嵌套循环方法出发，逐步优化至基于set的o(n)迭代方案，并最终展示如何优雅地将其转换为简洁且功能强大的stream api实现，包括带日志输出和仅返回结果的多种形式。
在处理整数列表数据时，一个常见的需求是判断列表中是否存在两个数，它们的和等于一个给定的目标值。例如，给定列表 [1, 3, 6, 9] 和目标值 8，我们需要判断是否存在 x + y = 8 的情况。
最直观的解决方案是使用嵌套循环遍历列表中的所有可能对。
import java.util.List;
public class Main {
static boolean validateArray(int result, List<Integer> array){
// 嵌套循环遍历所有可能的数对
for (int i = 0; i < array.size(); i++){
for (int j = i + 1; j < array.size(); j ++){ // 从 i+1 开始避免重复和自身相加
int value1 = array.get(i);
int value2 = array.get(j);
if(value1 + value2 == result){
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(validateArray(8, arrayTwo)); // 输出 true (6+2=8)
System.out.println(validateArray(8, arrayOne)); // 输出 false
}
}这种方法的时间复杂度为 O(n^2)，其中 n 是列表的长度。对于较小的列表，这可能不是问题，但当列表规模增大时，其性能会迅速下降。
为了提高效率，我们可以利用 Set 数据结构进行优化。Set 的 contains() 方法通常提供 O(1) 的平均时间复杂度，这使得我们可以在一次遍历中完成查找。
立即学习“Java免费学习笔记（深入）”；
基本思想是：对于列表中的每一个数字 num，我们计算它与目标值 result 的差值 complement = result - num。然后，我们检查这个 complement 是否已经存在于我们之前遍历过的数字集合中，或者是否存在于整个列表的 Set 表示中。
import java.util.List;
import java.util.Set;
import java.util.HashSet;
public class Main {
static boolean validateArrayOptimized(int result, List<Integer> array){
Set<Integer> set = new HashSet<>(array); // 将列表转换为Set，方便O(1)查找
for (Integer num : array) {
int complement = result - num;
// 检查补数是否存在于Set中
// 并且确保补数不是当前数字本身，以避免 4+4=8 的情况（如果列表中只有一个4）
if (set.contains(complement) && (result != 2 * num)) {
System.out.printf("找到 %s + %s = %s%n", num, complement, result);
return true;
}
}
System.out.printf("未找到两个数之和为 %s%n", result);
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, 2, 6); // 4+4=8 的情况，但列表中只有一个4
System.out.println(validateArrayOptimized(8, arrayTwo)); // 输出 true (找到 6 + 2 = 8)
System.out.println(validateArrayOptimized(8, arrayOne)); // 输出 false
System.out.println(validateArrayOptimized(8, arrayThree)); // 输出 false (因为 result != 2 * num)
}
}这个优化后的迭代方法将时间复杂度降低到了 O(n)，因为它只需要一次遍历列表，并且每次查找操作都是 O(1)。Set.copyOf(array)（Java 9+）或 new HashSet<>(array) 可以用来创建 Set。result != 2 * num 条件用于确保我们找到的是两个不同的数字（或至少是两个在集合中独立存在的互补数），避免了当目标值是某个数字的两倍，但列表中只有一个该数字时，将其自身作为补数的情况。
基于 Set 的优化方法非常适合转换为 Java 8 Stream API。Stream API 提供了一种更声明式、更简洁的方式来处理集合数据。
如果我们需要在找到结果时打印出具体是哪两个数字，可以使用 filter、findFirst 和 map/orElseGet 组合。
import java.util.List;
import java.util.Set;
import java.util.HashSet;
import java.util.stream.Collectors;
public class StreamApiWithLogging {
static boolean validateArrayWithStreamLogging(int result, List<Integer> array){
// 使用 Set.copyOf(array) (Java 9+) 或 new HashSet<>(array)
Set<Integer> set = new HashSet<>(array);
return array.stream()
.filter(num -> {
int complement = result - num;
// 过滤条件：补数存在于Set中，且目标值不等于当前数字的两倍
return set.contains(complement) && (result != 2 * num);
})
.findFirst() // 找到第一个符合条件的数字
.map(num -> {
// 如果找到了，打印日志并返回 true
System.out.printf("通过 Stream API 找到 %s + %s = %s%n", num, result - num, result);
return true;
})
.orElseGet(() -> {
// 如果未找到，打印日志并返回 false
System.out.printf("通过 Stream API 未找到两个数之和为 %s%n", result);
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);
validateArrayWithStreamLogging(8, arrayTwo); // 输出 true (找到 6 + 2 = 8)
validateArrayWithStreamLogging(8, arrayOne); // 输出 false
}
}在这个Stream版本中：
如果仅仅需要一个布尔结果，判断是否存在这样的数对，Stream API 可以提供一个更简洁的版本，使用 anyMatch。
import java.util.List;
import java.util.Set;
import java.util.HashSet;
public class StreamApiResultOnly {
static boolean validateArrayWithStream(int result, List<Integer> array){
Set<Integer> set = new HashSet<>(array); // 或 Set.copyOf(array)
// 使用 anyMatch 简洁地判断是否存在符合条件的元素
return array.stream()
.anyMatch(num -> set.contains(result - num) && (result != 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(validateArrayWithStream(8, arrayTwo)); // 输出 true
System.out.println(validateArrayWithStream(8, arrayOne)); // 输出 false
}
}anyMatch() 是一个终端操作，它在流中找到任何一个匹配给定谓词的元素时立即返回 true，否则在遍历完整个流后返回 false。这使得代码非常简洁且表达力强。
Java 8 Stream API 提供了一种强大而富有表现力的方式来处理集合数据。结合适当的数据结构（如 Set），我们可以将传统上效率低下的算法（如 O(n^2) 的嵌套循环）优化为高效且简洁的 O(n) 解决方案。通过 filter、findFirst、map、orElseGet 或 anyMatch 等操作，Stream API 不仅使代码更易读，而且在某些场景下能更好地利用多核处理器进行并行处理（尽管在这个特定问题中，并行流的开销可能大于收益）。理解其背后的原理和适用场景，是编写高性能、可维护 Java 代码的关键。
以上就是Java 8 Stream API：高效迭代数组并解决“两数之和”问题的详细内容，更多请关注php中文网其它相关文章！
每个人都需要一台速度更快、更稳定的 PC。随着时间的推移，垃圾文件、旧注册表数据和不必要的后台进程会占用资源并降低性能。幸运的是，许多工具可以让 Windows 保持平稳运行。
广告Copyright 2014-2025 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号
462
收藏
