本文旨在深入解析一种在Java数组中查找并打印去重元素的算法，重点剖析其核心逻辑，特别是内层循环结束后 if (i == j) 条件的判断机制。通过代码示例和详细的逐步分析，帮助读者理解该算法如何有效识别数组中的唯一元素，并提供替代实现方案以供参考。
1. 引言：去重元素查找问题
在编程中，从一个包含重复元素的集合中找出所有唯一的（distinct）元素是一个常见需求。本文将探讨一种基于嵌套循环的算法实现，并详细解释其背后的逻辑，特别是许多初学者可能感到困惑的 if (i == j) 判断条件。
2. 算法实现与核心代码
以下是用于查找数组中去重元素的Java代码示例：
public class DistinctElementFinder {
public static void main(String[] args) {
int[] arr = {10, 10, 20, 30, 10, 20, 40, 30, 60, 100, 10};
int distinctCount = 0;
// 外层循环：遍历数组中的每一个元素
for (int i = 0; i < arr.length; i++) {
int j;
// 内层循环：将当前元素 arr[i] 与其之前的元素 arr[0]...arr[i-1] 进行比较
for (j = 0; j < i; j++) {
// 如果找到相同元素，说明 arr[i] 不是第一次出现，跳出内层循环
if (arr[i] == arr[j]) {
break;
}
}
// 判断条件：如果内层循环完整执行完毕（未通过 break 跳出），则 arr[i] 是一个去重元素
if (i == j) {
System.out.print(arr[i] + " ");
distinctCount++;
}
}
System.out.println("\n去重元素总数: " + distinctCount);
}
}3. 核心逻辑解析：if (i == j) 的奥秘
理解这个算法的关键在于 if (i == j) 这个条件。我们来逐步分析它的作用：
立即学习“Java免费学习笔记（深入）”；
外层循环 (for (int i = 0; i : 这个循环负责依次取出数组中的每一个元素 arr[i]，并判断它是否是一个去重元素。i 作为当前元素的索引。
-
内层循环 (for (j = 0; j : 对于每一个 arr[i]，内层循环会将其与数组中所有位于其 之前 的元素 (arr[0] 到 arr[i-1]) 进行比较。j 是用于遍历这些先前元素的索引。
- 目的: 检查 arr[i] 是否在它之前已经出现过。
-
中断条件 (if (arr[i] == arr[j]) { break; }): 如果在内层循环中，发现 arr[i] 与之前的某个 arr[j] 相等，这意味着 arr[i] 并不是一个新出现的去重元素（它之前已经出现过了）。
- 一旦找到匹配，break 语句会立即终止内层循环。此时，j 的值将是导致匹配的那个元素的索引，即 j
-
关键判断 (if (i == j)): 当内层循环结束后，程序会检查 i 和 j 的值是否相等。
- 情况一：i == j (去重元素) 如果内层循环 完整地执行完毕，并且 没有 通过 break 语句提前终止，这意味着 arr[i] 与它之前的任何元素都不相等。在这种情况下，j 会一直递增，直到 j 的值达到 i（即 j
- 情况二：i != j (重复元素) 如果内层循环 通过 break 语句提前终止，这意味着 arr[i] 在它之前的元素中找到了一个匹配项。此时，j 的值将是匹配发生时的索引，所以 j 必然小于 i。 因此，当 j 不等于 i 时，就表明 arr[i] 是一个重复元素，不应该被打印。
4. 逐步示例分析
我们以 arr = {10, 10, 20, 30} 为例进行手动推演：
-
i = 0, arr[i] = 10
- 内层循环 j=0; j
- 循环结束后，j 仍为 0。
- if (i == j) -> if (0 == 0) 为真。打印 10。distinctCount = 1。
-
i = 1, arr[i] = 10
- 内层循环 j=0; j
- j = 0: arr[1] (10) == arr[0] (10) 为真。break 内层循环。
- 循环结束后，j 为 0。
- if (i == j) -> if (1 == 0) 为假。不打印。
-
i = 2, arr[i] = 20
- 内层循环 j=0; j
- j = 0: arr[2] (20) == arr[0] (10) 为假。
- j = 1: arr[2] (20) == arr[1] (10) 为假。
- 内层循环正常结束，j 递增到 2。
- if (i == j) -> if (2 == 2) 为真。打印 20。distinctCount = 2。
-
i = 3, arr[i] = 30
- 内层循环 j=0; j
- j = 0: arr[3] (30) == arr[0] (10) 为假。
- j = 1: arr[3] (30) == arr[1] (10) 为假。
- j = 2: arr[3] (30) == arr[2] (20) 为假。
- 内层循环正常结束，j 递增到 3。
- if (i == j) -> if (3 == 3) 为真。打印 30。distinctCount = 3。
最终输出：10 20 30，去重元素总数: 3。
5. 注意事项与替代方案
5.1 注意事项
- 时间复杂度: 该算法的时间复杂度为 O(n^2)，其中 n 是数组的长度。对于大型数组，性能可能不佳。
- 空间复杂度: 该算法的空间复杂度为 O(1)，因为它只使用了常数额外的空间（count, i, j 变量）。
5.2 替代方案
对于更高效地查找去重元素，尤其是处理大型数据集时，可以考虑使用哈希表（Hash Table）或集合（Set）数据结构。
使用 HashSet 的方法（推荐）:
HashSet 是一种不允许包含重复元素的集合。利用这一特性，我们可以非常简洁高效地找出所有去重元素。
import java.util.HashSet;
import java.util.Set;
public class DistinctElementFinderOptimized {
public static void main(String[] args) {
int[] arr = {10, 10, 20, 30, 10, 20, 40, 30, 60, 100, 10};
Set distinctElements = new HashSet<>();
// 遍历数组，将每个元素添加到 HashSet 中
// HashSet 会自动处理重复元素，只保留唯一值
for (int element : arr) {
distinctElements.add(element);
}
System.out.println("去重元素: " + distinctElements);
System.out.println("去重元素总数: " + distinctElements.size());
}
} - 时间复杂度: 使用 HashSet 的方法平均时间复杂度为 O(n)，因为 add 操作的平均时间复杂度为 O(1)。
- 空间复杂度: 空间复杂度为 O(k)，其中 k 是去重元素的数量（最坏情况下 k=n）。
6. 总结
本文详细解析了通过嵌套循环查找数组去重元素的算法，重点阐明了 if (i == j) 条件如何作为判断元素是否独特的关键。该方法虽然直观且不占用额外空间，但在性能上存在 O(n^2) 的局限性。在实际开发中，推荐使用 HashSet 等数据结构，以获得更优异的 O(n) 平均时间复杂度性能，从而更高效地解决去重问题。理解不同算法的原理和其性能特点，是编写高质量代码的重要一步。
