Java数组找交集：避免零值干扰与索引管理技巧

问题剖析：为什么会出现0？

在Java中，当我们创建一个新的整型数组时，如果未显式初始化其元素，它们将自动被赋予默认值0。在查找两个数组交集并存储到新数组的场景中，如果新数组的创建和填充逻辑存在缺陷，就可能导致数组中出现不必要的0。原始代码中存在两个主要问题导致了这一现象：

1. 不正确的数组大小预估： 原始代码将 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的数组

2. 元素填充时的索引管理错误： 在填充 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。

核心概念：动态索引管理

要解决上述问题，关键在于理解并实现“动态索引管理”。在向一个新数组中添加元素时，我们不能简单地复用源数组的索引。相反，我们需要一个独立的、专门用于跟踪新数组当前已填充位置的索引。这个索引只在每次成功添加一个元素时才递增。

解决方案与代码实现

我们将分两步修正代码：

步骤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; // 返回包含交集元素的数组
    }
}

注意事项与最佳实践

1. 数组大小预估的重要性： 在Java中，一旦数组被创建，其大小就固定了。因此，准确预估所需大小至关重要。如果无法预估，或者交集元素数量可能很大且不确定，使用动态数据结构（如 java.util.ArrayList）会是更好的选择，因为它能自动扩容。

   // 使用ArrayList的示例
   import java.util.ArrayList;
   import java.util.List;
   
   public static int[] intersectionsUsingList(int arr1[], int arr2[]) {
       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]) {
                   intersectionList.add(arr1[i]);
                   break;
               }
           }
       }
       // 将List转换为int[]
       return intersectionList.stream().mapToInt(Integer::intValue).toArray();
   }

2. 处理重复元素： 原始问题提到“只取一次”。在当前代码中，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[]) {
       Set set1 = 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();
   }

3. 调试技巧： 当遇到数组索引或值异常时，利用 System.out.println() 语句打印关键变量（如循环索引 i、j、新数组索引 newArrayIndex）的值，或者使用IDE的调试器设置断点并逐步执行，是定位问题的有效方法。

总结

本文详细探讨了在Java中查找数组交集时，新数组首位出现0的常见问题及其解决方案。核心在于理解数组的默认值行为，并正确管理数组的创建大小和元素填充时的索引。通过将 newArraysize 初始化为0，并引入一个独立的 newArrayIndex 来跟踪新数组的填充位置，可以确保生成一个精确、无冗余零值的交集数组。同时，文章也提供了使用 ArrayList 和 HashSet 的替代方案，以适应更复杂的场景，例如不确定数组大小或需要处理唯一交集元素的需求。掌握这些基础知识对于编写健壮和高效的Java数组操作代码至关重要。