跳转到内容
万象方舟

Java数组去重技巧详解，如何高效实现数组去重？

灿婴映
·
2025-07-03 15:14:32
阅读18分钟
已读42次

Java数组去重的常用方法有1、借助集合（如HashSet）去重；2、使用双重循环遍历比对；3、利用Stream流API处理；4、排序后去除相邻重复元素。其中，借助HashSet实现数组去重最为高效和简便，它利用集合不允许重复元素的特性，能在保证原始数据顺序或内容的前提下迅速完成去重操作。具体实现时，只需将数组元素逐一添加到HashSet中，再将其转回数组即可。这种方式不仅代码简洁、执行效率高，还能有效避免手动遍历带来的冗余和错误。下面将详细介绍Java数组去重的多种实现方式及其优缺点，帮助开发者根据实际需求选择最佳方案。

《java数组去重》

一、JAVA数组去重的常用方法概述

Java原生数组不支持直接去重操作，因此需要借助其他数据结构或工具进行处理。主流的去重方法如下：

方法主要思路优点缺点
HashSet集合法利用集合不允许重复元素特性简单高效，代码量少无法保证原始顺序
LinkedHashSet法HashSet基础上维持插入顺序去重同时保持元素顺序占用更多内存
双层循环遍历法嵌套两层for循环逐一比对无需额外库，适合小规模数据低效，代码冗长
排序+遍历法排序后只保留相邻不同元素实现简单，对有序需求适用改变原始顺序
Stream流APIJava8引入流式distinct()操作语义清晰，链式编程风格性能依赖具体实现

以上方法各有优势与适用场景，选择时需结合项目需求与数据规模。

二、HASHSET集合辅助法详解（推荐）

HashSet是Java集合框架中的一个类，实现了Set接口，其最大特点是不允许存储重复元素。这使它成为处理数组去重问题的一大利器。具体步骤如下：

  1. 创建一个空的HashSet实例。
  2. 遍历目标数组，将每个元素依次加入到HashSet。
  3. 利用HashSet自动过滤掉重复项。
  4. 将结果转换为所需类型的新数组返回。

示例代码：

import java.util.Arrays;
import java.util.HashSet;


public class ArrayDeduplication \{
public static int[] removeDuplicates(int[] arr) \{
HashSet<Integer> set = new HashSet<>();
for (int num : arr) \{
set.add(num);
\}
int[] result = new int[set.size()];
int i = 0;
for (int num : set) \{
result[i++] = num;
\}
return result;
\}


public static void main(String[] args) \{
int[] arr = \{1, 3, 5, 3, 7, 9, 1, 9\};
System.out.println(Arrays.toString(removeDuplicates(arr)));
\}
\}

输出示例：

[1, 3, 5, 7, 9]
  • 优点分析：
  • 时间复杂度低（平均O(n)）。
  • 编码简单，无需手动判断重复。
  • 注意事项：
  • 不保证输出顺序，如需保持顺序可使用LinkedHashSet。

三、LINKEDHASHSET实现有序去重

若要求保留原始数据在数组中的出现顺序，可以采用LinkedHashSet替代普通HashSet。其内部维护了一个链表，可以记录插入元素的先后次序。

示例代码：

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


public class OrderedArrayDeduplication \{
public static int[] removeDuplicatesOrdered(int[] arr) \{
LinkedHashSet<Integer> set = new LinkedHashSet<>();
for (int num : arr) \{
set.add(num);
\}
int[] result = new int[set.size()];
int i = 0;
for (int num : set) \{
result[i++] = num;
\}
return result;
\}


public static void main(String[] args) \{
int[] arr = \{4, 6, 4, 1, 6\};
System.out.println(Arrays.toString(removeDuplicatesOrdered(arr)));
\}
\}

输出示例：

[4, 6, 1]
  • 适合场景：
  • 对结果集顺序敏感的数据处理任务。
  • 性能说明：
  • 较普通HashSet略慢，但仍远优于双层循环。

四、双层循环遍历法（原理直观但效率低）

这种方式通过两层for循环逐个比较每个元素是否已存在于新建结果集中，从而决定是否添加。

伪代码步骤：

  1. 新建空List/临时存储结果。
  2. 外层循环遍历待处理数组所有项。
  3. 内层循环检查当前项是否已存在于结果中。
  4. 不存在则加入结果，否则跳过。

核心实现如下：

import java.util.ArrayList;


public class DoubleLoopDeduplication \{
public static int[] removeDuplicates(int[] arr) \{
ArrayList<Integer> list = new ArrayList<>();
for (int i=0; i<arr.length; i++) \{
boolean exists = false;
for (int j=0; j<list.size(); j++) \{
if (arr[i] == list.get(j)) \{
exists = true;
break;
\}
\}
if (!exists) list.add(arr[i]);
\}
// 转换为int[]
return list.stream().mapToInt(Integer::valueOf).toArray();
\}
\}
  • 优缺点分析：
  • 优点：无需第三方库/工具类；逻辑直观易懂。
  • 缺点：时间复杂度O(n^2)，大规模数据下极易超时，不建议在生产环境用于大批量数据处理。

五、排序+遍历法（适用于有排序需求场合）

此方法首先对原始数组进行排序，然后从头到尾扫描，仅保留相邻不同值。整体流程如下表所示：

步骤操作说明
排序对目标数组进行升/降排序
初始化新列表添加第一个元素
遍历与比较从第二个起，每次与前一项对比，不同则添加

示例代码片段：

import java.util.Arrays;


public class SortAndUniqueDeduplication \{
public static int[] removeDuplicates(int[] arr) \{
Arrays.sort(arr);
ArrayList<Integer> list = new ArrayList<>();
if (arr.length >0 ) list.add(arr[0]);
for(int i=1;i<arr.length;i++)\{
if(arr[i]!=arr[i-1]) list.add(arr[i]);
\}
return list.stream().mapToInt(Integer::valueOf).toArray();
\}
\}
  • 优缺点分析：
  • 优点：可结合业务要求完成排序和去重一步到位。
  • 缺点：会打乱输入数据本来的排列顺序，不适用于需要保持原始结构的数据集。

六、STREAM流API方式（函数式编程风格）

自Java8起，可利用Stream API提供的distinct()方法快速过滤掉重复值，极大提升开发效率。典型写法如下：

import java.util.Arrays;


public class StreamDeduplicationDemo\{
public static void main(String []args)\{
int []arr=\{10,20,10,40\};
// 使用streams完成基本类型dedup
int []unique= Arrays.stream(arr).distinct().toArray();
System.out.println(Arrays.toString(unique));
\}
\}

对于引用类型对象，可以配合自定义条件，例如根据某字段唯一等，更具有灵活性。例如针对字符串或自定义对象列表进行属性级别的唯一过滤等。

  • 优势分析：
  • 极致简洁；链式调用更符合函数式思维习惯；
  • 自动并行化支持，可进一步提升性能；
  • 注意事项：
  • 对老版本JDK或特殊场景兼容性有限；
  • 某些情况下转换操作可能导致装箱拆箱开销；

七、多种方式性能及适用性对比总结表格

针对上述几种常见方法进行综合比较，如下表所示：

方法保持输入顺序时间复杂度空间复杂度推荐场景
HashSet否O(n)O(n)快速无关顺序 dedup
LinkedHashSet是O(n)O(n)+链表指针占用_顺序敏感型 dedup
双层for是O(n^2)O(n)小体量且无工具依赖情形
排序+遍历否 (O(nlogn)) (O(1)-O(n)) 已排好或要求升降排序输出
Stream distinct() 视情况而定 O(n)-O(logn)(视底层实现)O(n)/自动管理 Java8及以上新项目推荐

综合来看：

  • 数据体量较小时任意方案均可胜任；
  • 数据量大时首选基于哈希/流式API等O(n)/O(logn)，拒绝嵌套暴力枚举；
  • 若要稳定保留输入出现先后关系，则建议采用LinkedHashSet或Stream(带sorted)。

八、特殊类型和进阶应用说明——自定义对象如何去重？

对于非基本类型，如自定义对象（例如Person），如果直接放入set中，需要合理覆写equals()和hashCode()方法，否则无法正确识别“内容相同”的实例。例如以身份证号唯一作为判定标准，则可按如下设计:

class Person\{
private String idCardNo; // 身份证号
private String name;
// ...省略getter/setter


@Override
public boolean equals(Object obj)\{
if(this==obj)return true;
if(obj==null || getClass()!=obj.getClass())return false;
Person other=(Person)obj;
return idCardNo.equals(other.idCardNo);
\}


@Override
public int hashCode()\{
return idCardNo.hashCode();
\}
\}

这样便可以直接利用上述任意set-based方案完成基于idCardNo唯一性的“人”对象的dedup。如果使用Stream API，则还可以通过Collectors.toMap或者分组归并进一步灵活筛选出代表性条目。

九、防止常见错误与优化建议说明

实际开发过程中容易遇到以下误区：

  • 忽视基本类型包装类自动拆装箱问题导致性能下降；
  • 错误理解equals/hashCode覆盖规则导致不同内容被错误认定为同一对象；
  • 在多线程环境下直接复用非线程安全集合引发竞态条件；

优化建议：

  1. 大批量数据批处理尽可能使用Stream并行化能力；
  2. 若涉及频繁增删查改，可考虑Guava等第三方库提供更丰富功能特性；
  3. 明确业务唯一判定逻辑，并据此覆写equals/hashCode而非默认地址判定；

十、结论及行动指南建议

综上所述，Java中的数组去重主要可通过集合辅助（尤其是哈希类）、双层遍历、排序策略以及现代函数式API四大路径实现。对于绝大多数日常开发任务，推荐首选基于(Hash/LinkedHash)set或者stream distinct方案，在保证高效可靠同时兼顾灵活扩展。如果涉及自定义业务逻辑判等，应特别关注对象属性级别的一致性定义。此外，在面对大规模、高并发或者特殊性能敏感场景时，应充分考虑算法复杂度和系统资源占用情况，并结合单元测试确保功能正确无误。下一步，你可以根据本文给出的范例模板，将其整合到你的项目工具库中，以便随时调用，大幅提高日常编码效率。如有更复杂的数据清洗需求，也可探索第三方开源工具包如Apache Commons Collections等，实现更高级的数据预处理能力。

精品问答:

Java数组去重有哪些常用方法？

我在处理Java数组时遇到了重复元素的问题，想知道有哪些高效且常用的Java数组去重方法？希望能了解不同方法的优缺点和适用场景。

Java数组去重常用方法包括：

  1. 使用HashSet去重：利用HashSet不允许重复元素的特性，将数组转换为HashSet，再转回数组。适合无序去重。

  2. 双重循环遍历法：通过嵌套循环比较元素，手动剔除重复，适合小规模数组但时间复杂度较高（O(n²)）。

  3. 排序后遍历法：先对数组排序，再遍历时跳过相邻重复元素，提高效率，时间复杂度O(nlogn)。

  4. 使用Stream API（Java 8及以上）：通过Arrays.stream(array).distinct()实现简洁高效的去重。

方法时间复杂度适用场景优缺点
HashSetO(n)无序去重简单快速，但顺序不可控
双重循环O(n²)小规模数据代码直观，但效率低
排序后遍历O(nlogn)有序需求保留顺序但需排序
Stream.distinct()O(n)函数式编程习惯者简洁且易读，但需Java 8及以上版本

根据具体需求选择最合适的方法。

如何使用HashSet实现Java数组去重？

我听说使用HashSet可以方便地实现Java数组去重，但不太清楚具体操作步骤和原理，希望能了解一个简单示例以及相关注意事项。

使用HashSet实现Java数组去重的步骤如下：

  1. 创建一个HashSet对象，用于存储唯一元素。
  2. 遍历原始数组，将每个元素加入HashSet中。
  3. 将HashSet转换回数组。

示例代码：

import java.util.*;
public class ArrayDeduplication {
    public static Integer[] removeDuplicates(Integer[] array) {
        Set<Integer> set = new HashSet<>(Arrays.asList(array));
        return set.toArray(new Integer[0]);
    }
}

注意事项:

  • HashSet不保证元素顺序，如果需要保留顺序，可以使用LinkedHashSet。
  • 对于基本类型（如int[]），需先转换为包装类（如Integer[]）才能直接使用集合类。
  • 时间复杂度平均为O(n)，性能较优。

Java中如何利用Stream API进行数组去重？

我想用更现代化的方式在Java中进行数组去重，听说Stream API很方便，但不太明白怎么用它来完成这个功能，希望有详细步骤和示例代码。

在Java 8及以上版本，可以利用Stream API轻松实现数组去重。核心是调用distinct()方法，该方法返回一个无重复元素的流，最后收集成新数组。

示例代码：

import java.util.Arrays;
public class StreamDeduplication {
    public static Integer[] removeDuplicates(Integer[] array) {
        return Arrays.stream(array)
                     .distinct()
                     .toArray(Integer[]::new);
    }
}

特点与优势：

  • 简洁明了，函数式编程风格，提高代码可读性。
  • 时间复杂度接近O(n)，效率较高。
  • 支持链式操作，方便后续扩展，如过滤、排序等。

若处理基本类型int[]，可以先转换为IntStream再调用distinct()。

为什么排序后再遍历是有效的Java数组去重方案？

我看到有人建议先对Java数组排序，然后再遍历删除重复元素，这种方法具体为什么有效，有没有详细解释和案例可以帮助理解？

排序后再遍历的方法基于这样一个原理：相同元素在排序后的连续位置上出现，因此只需比较相邻两个元素即可判断是否重复，从而避免了全局比较带来的高昂开销。

步骤说明：

  1. 对原始数组进行升序或降序排序（时间复杂度O(nlog n))。2. 从头开始遍历已排序的数组，将第一个遇到的新值保存到结果集合中，如果当前值与前一值不同则加入结果集，否则跳过。3. 最终得到无重复的新集合或新数组。示例伪代码:for i in range(1, array.length): if array[i] != array[i - 1]: add to result|优势| 说明||-|-||时间复杂度| 排序O(nlog n)，遍历O(n)，整体效率较好||空间复杂度| 原地操作可能减少额外空间需求||保留顺序| 有条件下可保持部分有序性|总之，通过预先排序，把无序问题转化为局部邻近检测，大幅降低了比较次数，使得大规模数据下的去重要更高效、更实用。

文章版权归" "blog.vientianeark.cn所有。
转载请注明出处：https://blog.vientianeark.cn/p/2193/
温馨提示：文章由AI大模型生成，如有侵权，联系 mumuerchuan@gmail.com 删除。

京ICP备2023022514号-1 |© 2023 www.vientianeark.cn 万象方舟  | 网站地图 | Devops开发者社区