1. Java数组的默认初始化行为
在java中，当我们声明并初始化一个基本数据类型的数组时，如果未显式地为数组元素赋值，它们将自动被赋予其数据类型的默认值。对于int类型的数组，其默认值是0。这意味着，如果你创建一个int[]数组，但没有填充所有索引位置，那么那些未被赋值的位置将保持为0。这正是导致新数组首位出现0的一个重要前提。
2. 问题分析：原始代码的逻辑缺陷
原始代码尝试找到两个整数数组arr1和arr2的交集，并将其存储到一个新的数组newArray中。然而，其实现中存在两个关键的逻辑缺陷，导致了不期望的0出现在结果数组的首位：
2.1 新数组大小计算不准确
int newArraysize=1; // 缺陷：初始值设为1 // ... 循环计算匹配元素数量 ... newArraysize++; // 每找到一个匹配，尺寸增加1
在计算newArraysize时，变量被初始化为1。这意味着即使没有找到任何匹配元素，newArraysize也会至少为1。如果找到了N个匹配元素，最终newArraysize会是N+1。这导致newArray被创建时，其大小总是比实际所需的空间多一个。这个多出来的空间，由于Java数组的默认初始化行为，会是一个0。
2.2 元素填充时的索引错误
// ... 循环查找匹配元素 ...
if(arr1[i]==arr2[j])
{
newArray[i] = arr1[i]; // 缺陷：使用arr1的索引i来填充newArray
System.out.println(arr1[i]+" moved to "+ newArray[i]);
break; // 找到一个匹配后跳出内层循环
}这是导致0出现在新数组首位的核心原因。在填充newArray时，代码使用了外层循环变量i（即arr1的当前索引）作为newArray的索引。
考虑以下场景： 假设arr1 = {6, 9, 8, 5}，arr2 = {9, 2, 4, 1, 8}。
- 当i=0时，arr1[0]是6。6在arr2中没有匹配项。所以newArray[0]不会被赋值，它将保持默认值0。
- 当i=1时，arr1[1]是9。9在arr2中找到匹配项。此时执行newArray[1] = arr1[1]，即newArray[1] = 9。
- 当i=2时，arr1[2]是8。8在arr2中找到匹配项。此时执行newArray[2] = arr1[2]，即newArray[2] = 8。
- 当i=3时，arr1[3]是5。5在arr2中没有匹配项。所以newArray[3]不会被赋值，它将保持默认值0。
最终，如果newArraysize被计算为3（因为9和8两个匹配，加上初始的1），那么newArray的大小是3。根据上述填充逻辑，newArray的实际内容可能是[0, 9, 8]（newArray[0]未被赋值，newArray[1]为9，newArray[2]为8）。这与期望的[9, 8]不符，并且首位的0就是由于newArray[0]没有被有效匹配元素填充而保留的默认值。
立即学习“Java免费学习笔记（深入）”；
3. 解决方案：正确获取数组交集
为了正确地获取两个数组的交集并避免上述问题，我们可以采用以下两种常见且推荐的方法。
3.1 方法一：两阶段处理（先计数，后填充）
这种方法分为两个主要阶段：
- 第一阶段：精确计算匹配元素数量。 在这一阶段，我们只遍历数组并计算实际的匹配元素数量，以确定新数组的准确大小。
- 第二阶段：使用独立索引填充新数组。 在这一阶段，我们再次遍历数组，当找到匹配元素时，将其添加到新数组中，并使用一个独立的计数器作为新数组的索引，确保元素按顺序紧密排列。
package Arrays;
import java.util.Arrays;
public class ArrayIntersectionCorrect {
public static void main(String[] args) {
int arr1[] = new int[]{6, 9, 8, 5};
int arr2[] = new int[]{9, 2, 4, 1, 8};
intersections(arr1, arr2);
}
public static void intersections(int arr1[], int arr2[]) {
// 第一阶段：计算交集元素的准确数量
int matchCount = 0;
for (int i = 0; i < arr1.length; i++) {
for (int j = 0; j < arr2.length; j++) {
if (arr1[i] == arr2[j]) {
// 找到了一个匹配
matchCount++;
// 如果每个arr1元素只匹配一次，找到后可以跳出内层循环
break;
}
}
}
// 根据精确的匹配数量创建新数组
int newArray[] = new int[matchCount];
// 第二阶段：填充新数组，使用独立的索引
int newArrayIndex = 0; // 新数组的当前填充索引
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;
}
}
}
System.out.println("交集数组: " + Arrays.toString(newArray));
}
}运行结果:
交集数组: [9, 8]
3.2 方法二：使用动态数组（ArrayList）
在Java中，当你不确定最终需要多少元素时，使用动态数组（如ArrayList）是更灵活和推荐的做法。ArrayList可以根据需要自动扩容，省去了预先计算数组大小的麻烦。
package Arrays;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class ArrayIntersectionArrayList {
public static void main(String[] args) {
int arr1[] = new int[]{6, 9, 8, 5};
int arr2[] = new int[]{9, 2, 4, 1, 8};
intersectionsWithArrayList(arr1, arr2);
}
public static void intersectionsWithArrayList(int arr1[], int arr2[]) {
// 创建一个ArrayList来存储交集元素
List intersectionList = new ArrayList<>();
for (int i = 0; i < arr1.length; i++) {
for (int j = 0; j < arr2.length; j++) {
if (arr1[i] == arr2[j]) {
// 将匹配元素直接添加到ArrayList中
intersectionList.add(arr1[i]);
// 找到一个匹配后跳出内层循环，避免重复添加
break;
}
}
}
// 如果需要将结果转换为原始的int[]数组
int[] newArray = new int[intersectionList.size()];
for (int i = 0; i < intersectionList.size(); i++) {
newArray[i] = intersectionList.get(i);
}
System.out.println("交集数组 (使用ArrayList): " + Arrays.toString(newArray));
}
} 运行结果:
交集数组 (使用ArrayList): [9, 8]
这种方法代码更简洁，并且在处理不确定数量的交集元素时更加健壮。如果最终结果不需要是原始的int[]数组，直接返回ArrayList
4. 注意事项与最佳实践
-
唯一性处理: 原始问题提到“only once”，如果指的是交集结果中元素必须唯一（例如，arr1={1,2,2}和arr2={2,3}，结果是{2}而不是{2,2}），那么可以在将元素添加到ArrayList或newArray之前，先使用Set数据结构（如HashSet）来存储arr2中的元素，或者存储已找到的交集元素，以快速检查唯一性。
// 示例：使用HashSet优化查找和确保唯一性 import java.util.HashSet; import java.util.Set; // ... Set
set2 = new HashSet<>(); for (int num : arr2) { set2.add(num); } List intersectionList = new ArrayList<>(); for (int num : arr1) { if (set2.contains(num)) { // O(1) 平均时间复杂度查找 intersectionList.add(num); set2.remove(num); // 如果每个元素只匹配一次且从set2中移除，确保交集元素的唯一性 } } 调试的重要性: 当遇到代码行为与预期不符时，学会使用调试器（IDE如IntelliJ IDEA或Eclipse都内置了强大的调试功能）进行单步调试是至关重要的。通过观察变量（如i、j、newArrayIndex）在每一步的值变化，可以清晰地找出逻辑错误所在。
选择合适的数据结构: 根据具体需求选择最合适的数据结构。如果元素数量不确定或需要频繁增删，ArrayList是优选。如果需要快速查找和保证唯一性，HashSet是理想选择。如果最终结果必须是固定大小的原始数组，则需要仔细管理索引或先用ArrayList再转换。
5. 总结
在Java中处理数组交集时，意外的0值通常源于对数组默认初始化行为的忽视，以及对新数组大小预估和元素填充索引管理的疏忽。通过本文的分析，我们了解到，无论是采用两阶段处理的传统数组方式，还是利用ArrayList的动态特性，核心都在于确保新数组的创建大小是精确的，并且在填充元素时，使用一个独立的、正确递增的索引来放置元素，避免与源数组的索引混淆。掌握这些基本原则和实践，将有助于编写出更健壮、更符合预期的Java数组处理代码。
