Java实现Codewars数组差函数返回内存地址而非值问题求助

这是Codewars平台的Java编程任务，要求实现一个数组差函数：从数组a中移除所有在数组b中出现的元素，保留原顺序。例如Kata.arrayDiff(new int[] {1, 2, 2, 2, 3}, new int[] {2})应返回new int[] {1, 3}。现在代码逻辑写完后，返回结果是数组的内存地址而非预期值，附上代码请求帮助：

import java.util.*;

public class Kata {
    public static int[] arrayDiff(int[] a, int[] b) {

        ArrayList<Integer> listA = new ArrayList<Integer>();
        ArrayList<Integer> listB = new ArrayList<Integer>();

        for (int i = 0; i < a.length; i++) {
            listA.add(a[i]);
//            listA.get(i);
        }

        for (int j = 0; j < b.length; j++) {
            listB.add(b[j]);
//            listB.get(j);
        }

        int[] newA = convertToInt(listA); //convert ArrayList to Int[]
        int[] newB = convertToInt(listB); //convert ArrayList to Int[]
        //Merge Arrays
        int al = newA.length;
        int bl = newB.length;
        int[] res = new int[al + bl];
        System.arraycopy(newA, 0, res, 0, al);
        System.arraycopy(newB, 0, res, al, bl);

//        System.out.println(Arrays.toString(res));
        // End of Merging
        removeDups(res);
        Arrays.sort(res);
        System.out.println("Sort: "+Arrays.toString(res));

//        System.out.println(listA);
//        System.out.println(listB);

        return res;
    }

    private static int[] convertToInt(ArrayList<Integer> listA) {
        Object[] obj_arr = listA.toArray();
        int[] arr = new int[listA.size()];
        for (int i = 0; i < obj_arr.length; i++) {
            arr[i] = (int) obj_arr[i];
        }

//        for (int i=0;i<arr.length;i++)
//        {
//            System.out.println(arr[i]);
//        }

        return arr;
    }

    public static void removeDups(int[] a){
        LinkedHashSet<Integer> set = new LinkedHashSet<Integer>();

        // adding elements to LinkedHashSet
        for (int i = 0; i < a.length; i++)
            set.add(a[i]);

        // Print the elements of LinkedHashSet
//        System.out.print(set);
    }
}

问题分析与修正方案 #

你的代码存在几个核心问题：

1. 逻辑完全偏离任务要求：你把数组a和b合并后去重排序，这和“从a中移除b里的元素”的需求完全不符，任务是保留a中不在b内的元素，而非合并去重。
2. removeDups方法无效：该方法仅将数组元素存入LinkedHashSet，但既没有修改原数组，也没有返回去重后的数组，调用后对res数组无任何影响。
3. 返回数组长度错误：你创建的res数组长度是a+b的总长度，即使逻辑正确，也会包含大量未赋值的默认值0。
4. 关于“返回内存地址”：Java中直接打印数组会输出其哈希码（看起来像内存地址），这是正常现象，需要用Arrays.toString()打印数组内容，但你的核心问题是返回的数组本身不符合要求。

下面是修正后的代码：

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Set;

public class Kata {
    public static int[] arrayDiff(int[] a, int[] b) {
        // 将b的元素存入Set，实现O(1)时间复杂度的查找
        Set<Integer> bElements = new HashSet<>();
        for (int num : b) {
            bElements.add(num);
        }

        // 遍历a，收集不在b中的元素，保留原顺序
        ArrayList<Integer> resultList = new ArrayList<>();
        for (int num : a) {
            if (!bElements.contains(num)) {
                resultList.add(num);
            }
        }

        // 转换为int数组返回
        int[] result = new int[resultList.size()];
        for (int i = 0; i < resultList.size(); i++) {
            result[i] = resultList.get(i);
        }
        return result;
    }
}

修正说明 #

• 用HashSet存储数组b的元素，大幅提升元素存在性检查的效率。
• 严格遵循任务逻辑：遍历a数组，只保留不在b中的元素，同时维持原顺序。
• 返回的数组长度与结果元素数量完全匹配，无多余默认值。
• 测试时使用Arrays.toString(Kata.arrayDiff(...))即可看到正确的数组内容，而非哈希码。

内容的提问来源于stack exchange，提问作者Rizki Fajar