如何在不使用ArrayList的情况下从一个数组中移除另一个数组的元素？

嘿，这个问题我之前也碰到过，不用ArrayList确实得手动处理数组的长度和元素填充，但完全能实现！我给你分步骤讲清楚，先从你举的int数组例子入手，再扩展到你实际要用的float二维点坐标数组。

因为Java里数组的长度是固定的，所以得分成两步走：

1. 先统计原数组中需要保留的元素数量（也就是不在待移除数组里的元素个数），这样就能确定结果数组的长度。
2. 创建对应长度的结果数组，再遍历原数组，把符合条件的元素逐个填充进去。

先直接给你对应你例子的可运行代码：

public class ArrayRemoveExample {
    public static void main(String[] args) {
        int[] set01 = {1, 2, 3, 4, 5, 6};
        int[] set02 = {1, 2};
        int[] set03 = removeElements(set01, set02);
        
        // 打印验证结果
        for (int num : set03) {
            System.out.print(num + " "); // 输出：3 4 5 6
        }
    }

    // 核心方法：从arr1中移除arr2包含的元素
    private static int[] removeElements(int[] arr1, int[] arr2) {
        // 第一步：统计要保留的元素数量
        int keepCount = 0;
        for (int num : arr1) {
            if (!isElementInArray(arr2, num)) {
                keepCount++;
            }
        }

        // 第二步：创建结果数组并填充元素
        int[] result = new int[keepCount];
        int resultIndex = 0;
        for (int num : arr1) {
            if (!isElementInArray(arr2, num)) {
                result[resultIndex++] = num;
            }
        }
        return result;
    }

    // 辅助方法：判断单个元素是否在目标数组中
    private static boolean isElementInArray(int[] arr, int target) {
        for (int num : arr) {
            if (num == target) {
                return true;
            }
        }
        return false;
    }
}

你提到实际场景是float类型的点坐标{x,y}，这里要注意浮点数不能直接用==判断相等，得用一个极小的误差范围（比如1e-6）来判断两个坐标是否一致。代码如下：

public class PointArrayRemoveExample {
    public static void main(String[] args) {
        // 模拟你的可变长度ptSet
        float[][] ptSet = {{1.0f, 2.0f}, {3.0f, 4.0f}, {5.0f, 6.0f}, {1.0f, 2.0f}};
        float[][] toRemove = {{1.0f, 2.0f}};
        float[][] resultSet = removePoints(ptSet, toRemove);
        
        // 打印结果
        for (float[] point : resultSet) {
            System.out.println("(" + point[0] + ", " + point[1] + ")");
        }
    }

    private static float[][] removePoints(float[][] originalPoints, float[][] pointsToRemove) {
        // 统计需要保留的点数
        int keepCount = 0;
        for (float[] point : originalPoints) {
            if (!isPointInArray(pointsToRemove, point)) {
                keepCount++;
            }
        }

        // 创建结果数组并填充
        float[][] result = new float[keepCount][2];
        int resultIndex = 0;
        for (float[] point : originalPoints) {
            if (!isPointInArray(pointsToRemove, point)) {
                result[resultIndex++] = point;
            }
        }
        return result;
    }

    // 判断点是否在目标数组中（处理浮点数精度问题）
    private static boolean isPointInArray(float[][] arr, float[] targetPoint) {
        for (float[] point : arr) {
            // 用1e-6作为误差阈值，判断两个点是否相同
            if (Math.abs(point[0] - targetPoint[0]) < 1e-6 
                && Math.abs(point[1] - targetPoint[1]) < 1e-6) {
                return true;
            }
        }
        return false;
    }
}

如果你的待移除数组特别大，上面的线性查找（遍历待移除数组判断元素是否存在）效率会比较低。这时候可以用HashSet来存储待移除的元素（注意基本类型要转成包装类，比如Integer、Float），这样查找时间会从O(n)降到O(1)，提升整体性能。

比如优化后的int数组方法：

private static int[] removeElementsOptimized(int[] arr1, int[] arr2) {
    // 把待移除元素存入HashSet
    Set<Integer> removeSet = new HashSet<>();
    for (int num : arr2) {
        removeSet.add(num);
    }

    // 统计保留元素数量
    int keepCount = 0;
    for (int num : arr1) {
        if (!removeSet.contains(num)) {
            keepCount++;
        }
    }

    // 填充结果数组
    int[] result = new int[keepCount];
    int resultIndex = 0;
    for (int num : arr1) {
        if (!removeSet.contains(num)) {
            result[resultIndex++] = num;
        }
    }
    return result;
}

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