求适配Java示例主方法的removeDuplicates(ar)子方法实现

嘿，我来帮你搞定这个需求！你需要写一个removeDuplicates方法，既能去除数组里的重复元素，返回干净的新数组，还得保证原数组完全不变。这里有两种实用的实现方式，咱们一步步来看：

方案一：用Set集合快速去重（简洁高效） #

Set集合本身就不允许重复元素，用它来处理去重简直事半功倍。而且用LinkedHashSet还能保留元素在原数组里的出现顺序，完美匹配你给出的示例输出。

import java.util.Arrays;
import java.util.LinkedHashSet;
import java.util.Set;

class Example{ 
    public static void main(String []args) { 
        int[] ar={54,67,98,12,43,58,91,98,29,99,54,61}; 
        int[] newArray=removeDuplicates(ar); 
        System.out.println(Arrays.toString(ar));//[54,67,98,12,43,58,91,98,29,99,54,61] 
        System.out.println(Arrays.toString(newArray));//[54,67,98,12,43,58,91,29,99,61] 
    } 

    public static int[] removeDuplicates(int[] ar) {
        // LinkedHashSet会保留元素的原始顺序，HashSet则是无序的
        Set<Integer> uniqueElements = new LinkedHashSet<>();
        // 遍历原数组，把元素加入Set，自动过滤重复项
        for (int num : ar) {
            uniqueElements.add(num);
        }
        // 把Set转成int数组
        int[] result = new int[uniqueElements.size()];
        int idx = 0;
        for (int num : uniqueElements) {
            result[idx++] = num;
        }
        return result;
    }
}

为啥这么做？ #

• 用LinkedHashSet而不是普通HashSet，是因为它能维持元素在原数组里的先后顺序，和你示例里的输出完全一致。
• 整个过程没有修改原数组的任何元素，完全符合“原数组保持不变”的要求。
• 代码简洁易懂，时间复杂度是O(n)，效率很高。

方案二：手动遍历去重（不依赖集合框架） #

如果不想用集合类，想自己实现底层逻辑，那可以试试手动遍历的方式，适合需要更精细控制的场景：

import java.util.Arrays;

class Example{ 
    public static void main(String []args) { 
        int[] ar={54,67,98,12,43,58,91,98,29,99,54,61}; 
        int[] newArray=removeDuplicates(ar); 
        System.out.println(Arrays.toString(ar));//[54,67,98,12,43,58,91,98,29,99,54,61] 
        System.out.println(Arrays.toString(newArray));//[54,67,98,12,43,58,91,29,99,61] 
    } 

    public static int[] removeDuplicates(int[] ar) {
        // 先处理边界情况：空数组或只有一个元素，直接返回拷贝
        if (ar == null || ar.length <= 1) {
            return ar.clone();
        }

        // 第一步：统计不重复元素的数量，用来确定结果数组的长度
        int uniqueCount = 1;
        for (int i = 1; i < ar.length; i++) {
            boolean isDuplicate = false;
            // 对比当前元素和已经确认的不重复元素
            for (int j = 0; j < uniqueCount; j++) {
                if (ar[i] == ar[j]) {
                    isDuplicate = true;
                    break;
                }
            }
            if (!isDuplicate) {
                uniqueCount++;
            }
        }

        // 第二步：创建结果数组，填充不重复元素
        int[] result = new int[uniqueCount];
        result[0] = ar[0];
        int idx = 1;
        for (int i = 1; i < ar.length; i++) {
            boolean isDuplicate = false;
            for (int j = 0; j < idx; j++) {
                if (ar[i] == result[j]) {
                    isDuplicate = true;
                    break;
                }
            }
            if (!isDuplicate) {
                result[idx++] = ar[i];
            }
        }
        return result;
    }
}

思路拆解： #

1. 先处理特殊情况：如果原数组是空的或者只有一个元素，直接返回原数组的拷贝，避免后续逻辑出错，同时保证原数组不变。
2. 第一次遍历统计不重复元素的个数，这样就能知道结果数组需要多大的容量。
3. 第二次遍历把不重复的元素逐个放进结果数组里，同样保留原顺序。
4. 全程没有修改原数组的任何内容，完全符合需求。

两种方案都能完美解决你的问题，第一种更简洁高效，第二种适合理解底层逻辑。你可以根据自己的需求选择~

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