问题剖析：为什么会出现0？
在java中，当我们创建一个新的整型数组时，如果未显式初始化其元素，它们将自动被赋予默认值0。在查找两个数组交集并存储到新数组的场景中，如果新数组的创建和填充逻辑存在缺陷，就可能导致数组中出现不必要的0。原始代码中存在两个主要问题导致了这一现象：
-
不正确的数组大小预估： 原始代码将 newArraysize 初始化为1 (int newArraysize = 1;)。这意味着即使没有任何匹配元素，数组大小也会至少为1。对于每个找到的匹配元素，newArraysize 会在此基础上再加1。例如，如果实际只有两个匹配元素，newArraysize 最终会变成 1 + 2 = 3。这导致创建的数组比实际需要的空间多了一个位置。
int newArraysize = 1; // 问题：初始值不应为1 // ... 循环计算匹配元素数量 ... // 如果有2个匹配，newArraysize会变成3 int newArray[] = new int[newArraysize]; // 创建了一个大小为3的数组
-
元素填充时的索引管理错误： 在填充 newArray 时，原始代码使用了外层循环的索引 i 来作为 newArray 的索引 (newArray[i] = arr1[i];)。这是最核心的问题。
for(int i=0; i
考虑 arr1 = {6, 9, 8, 5} 和 arr2 = {9, 2, 4, 1, 8}。
- 当 i=0 时，arr1[0] 是6，与 arr2 无匹配。此时 newArray[0] 保持默认值0。
- 当 i=1 时，arr1[1] 是9，与 arr2[0] 的9匹配。newArray[1] 被赋值为9。
- 当 i=2 时，arr1[2] 是8，与 arr2[4] 的8匹配。newArray[2] 被赋值为8。
- 最终 newArray 结果为 [0, 9, 8]。
由于 arr1 中索引0的元素（即6）没有匹配项，newArray[0] 就从未被赋值，从而保留了其默认值0。
核心概念：动态索引管理
要解决上述问题，关键在于理解并实现“动态索引管理”。在向一个新数组中添加元素时，我们不能简单地复用源数组的索引。相反，我们需要一个独立的、专门用于跟踪新数组当前已填充位置的索引。这个索引只在每次成功添加一个元素时才递增。
解决方案与代码实现
我们将分两步修正代码：
立即学习“Java免费学习笔记（深入）”；
步骤1：精确计算交集元素数量
为了避免数组过大或过小，我们首先需要准确计算出交集元素的数量。newArraysize 应该从0开始计数。
package Arrays;
import java.util.Arrays;
public class ArrayIntersection {
public static void main(String[] args) {
int arr1[] = new int[] {6, 9, 8, 5};
int arr2[] = new int[] {9, 2, 4, 1, 8};
// 调用intersections方法并打印结果
int[] intersectionResult = intersections(arr1, arr2);
System.out.println("交集数组: " + Arrays.toString(intersectionResult));
}
public static int[] intersections(int arr1[], int arr2[]) {
// 步骤1：精确计算交集元素数量
int newArraysize = 0; // 修正：初始值应为0
for (int i = 0; i < arr1.length; i++) {
for (int j = 0; j < arr2.length; j++) {
if (arr1[i] == arr2[j]) {
// System.out.println(arr1[i] + " 和 " + arr2[j] + " 匹配!"); // 调试信息
newArraysize++;
break; // 找到一个匹配后，arr1[i]就不再与arr2中的其他元素比较
}
}
}
// System.out.println("计算出的交集大小: " + newArraysize); // 调试信息
// 如果没有交集，可以返回一个空数组或null
if (newArraysize == 0) {
return new int[0];
}
// 根据计算出的精确大小创建新数组
int newArray[] = new int[newArraysize];
// 步骤2：使用独立索引填充新数组
int newArrayIndex = 0; // 独立索引，用于跟踪newArray的当前填充位置
for (int i = 0; i < arr1.length; i++) {
for (int j = 0; j < arr2.length; j++) {
if (arr1[i] == arr2[j]) {
newArray[newArrayIndex] = arr1[i]; // 修正：使用newArrayIndex
// System.out.println(arr1[i] + " 移动到 newArray[" + newArrayIndex + "]"); // 调试信息
newArrayIndex++; // 成功添加一个元素后，递增独立索引
break; // 找到一个匹配后，arr1[i]就不再与arr2中的其他元素比较
}
}
}
return newArray; // 返回交集数组
}
}步骤2：使用独立索引填充新数组
在填充 newArray 时，引入一个名为 newArrayIndex 的独立变量。这个变量的唯一作用是记录 newArray 中下一个可用的插入位置。每当找到一个匹配元素并将其添加到 newArray 后，newArrayIndex 就自增1。
通过上述两步修正，newArray 的大小将是精确的，并且元素会从索引0开始连续填充，避免了中间出现0值。
完整示例代码
package Arrays;
import java.util.Arrays;
public class ArrayIntersection {
public static void main(String[] args) {
int arr1[] = new int[] {6, 9, 8, 5};
int arr2[] = new int[] {9, 2, 4, 1, 8};
// 调用intersections方法并打印结果
int[] intersectionResult = intersections(arr1, arr2);
System.out.println("交集数组: " + Arrays.toString(intersectionResult)); // 预期输出: [9, 8]
// 示例2：无交集
int arr3[] = new int[] {1, 2, 3};
int arr4[] = new int[] {4, 5, 6};
int[] noIntersection = intersections(arr3, arr4);
System.out.println("无交集数组: " + Arrays.toString(noIntersection)); // 预期输出: []
// 示例3：一个交集
int arr5[] = new int[] {1, 2, 3};
int arr6[] = new int[] {3, 4, 5};
int[] singleIntersection = intersections(arr5, arr6);
System.out.println("一个交集数组: " + Arrays.toString(singleIntersection)); // 预期输出: [3]
}
/**
* 查找两个整数数组的交集元素。
* 每个arr1中的元素在arr2中找到一个匹配后即停止查找，确保每个arr1元素只被考虑一次。
*
* @param arr1 第一个整数数组
* @param arr2 第二个整数数组
* @return 包含两个数组交集元素的整数数组。如果无交集，返回空数组。
*/
public static int[] intersections(int arr1[], int arr2[]) {
// 第一阶段：计算交集元素的数量
int intersectionCount = 0;
for (int i = 0; i < arr1.length; i++) {
for (int j = 0; j < arr2.length; j++) {
if (arr1[i] == arr2[j]) {
intersectionCount++;
break; // 找到一个匹配后，arr1[i]就不再与arr2中的其他元素比较
}
}
}
// 如果没有交集，直接返回一个空数组
if (intersectionCount == 0) {
return new int[0];
}
// 第二阶段：创建新数组并填充交集元素
int[] newArray = new int[intersectionCount];
int newArrayIndex = 0; // 独立索引，用于跟踪newArray的当前填充位置
for (int i = 0; i < arr1.length; i++) {
for (int j = 0; j < arr2.length; j++) {
if (arr1[i] == arr2[j]) {
newArray[newArrayIndex] = arr1[i]; // 将匹配元素放入新数组
newArrayIndex++; // 递增独立索引
break; // 找到一个匹配后，arr1[i]就不再与arr2中的其他元素比较
}
}
}
return newArray; // 返回包含交集元素的数组
}
}注意事项与最佳实践
-
数组大小预估的重要性： 在Java中，一旦数组被创建，其大小就固定了。因此，准确预估所需大小至关重要。如果无法预估，或者交集元素数量可能很大且不确定，使用动态数据结构（如 java.util.ArrayList）会是更好的选择，因为它能自动扩容。
// 使用ArrayList的示例 import java.util.ArrayList; import java.util.List; public static int[] intersectionsUsingList(int arr1[], int arr2[]) { ListintersectionList = new ArrayList<>(); for (int i = 0; i < arr1.length; i++) { for (int j = 0; j < arr2.length; j++) { if (arr1[i] == arr2[j]) { intersectionList.add(arr1[i]); break; } } } // 将List转换为int[] return intersectionList.stream().mapToInt(Integer::intValue).toArray(); } -
处理重复元素： 原始问题提到“只取一次”。在当前代码中，break 语句确保了 arr1 中的每个元素在 arr2 中只被匹配一次。如果 arr1 本身包含重复元素，且这些重复元素也在 arr2 中，它们都会被添加到结果数组中。例如，arr1={9,9}, arr2={9}，结果会是 [9,9]。如果期望结果数组中的元素是唯一的（即数学上的集合交集），则需要额外的去重逻辑，例如使用 java.util.HashSet：
import java.util.HashSet; import java.util.Set; public static int[] uniqueIntersections(int arr1[], int arr2[]) { Setset1 = new HashSet<>(); for (int num : arr1) { set1.add(num); } Set intersectionSet = new HashSet<>(); for (int num : arr2) { if (set1.contains(num)) { intersectionSet.add(num); } } // 将Set转换为int[] return intersectionSet.stream().mapToInt(Integer::intValue).toArray(); } 调试技巧： 当遇到数组索引或值异常时，利用 System.out.println() 语句打印关键变量（如循环索引 i、j、新数组索引 newArrayIndex）的值，或者使用IDE的调试器设置断点并逐步执行，是定位问题的有效方法。
总结
本文详细探讨了在Java中查找数组交集时，新数组首位出现0的常见问题及其解决方案。核心在于理解数组的默认值行为，并正确管理数组的创建大小和元素填充时的索引。通过将 newArraysize 初始化为0，并引入一个独立的 newArrayIndex 来跟踪新数组的填充位置，可以确保生成一个精确、无冗余零值的交集数组。同时，文章也提供了使用 ArrayList 和 HashSet 的替代方案，以适应更复杂的场景，例如不确定数组大小或需要处理唯一交集元素的需求。掌握这些基础知识对于编写健壮和高效的Java数组操作代码至关重要。
