Java List集合 去重的多种方法 (保留顺序和不保留顺序的)

本文详细介绍并提供了四种有效的Java List去重方法:双层循环删除重复元素、使用HashSet快速去重、删除重复元素同时保持原有顺序以及利用list.contains()进行去重。每种方法都附有详细的代码实现,帮助开发者根据实际需求选择最适合的去重策略。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

1.循环list中的所有元素然后删除重复

/**
* 循环list中的所有元素然后删除重复
* @param list 待去重的list
* @return 去重后的list
*/
public static <T> List<T> removeDuplicate(List<T> list){
  for(int i=0;i<list.size()-1;i++){
      for(int j=list.size()-1;j>i;j--){
          if (list.get(j).equals(list.get(i))){
              list.remove(j);
          }
      }
  }
  return list;
}

2.通过HashSet去重

/**
 * 通过HashSet去重
 * @param list 待去重的list
 * @return 去重后的list
 */
public static <T> List<T> removeDuplicateHashSet(List<T> list){
    HashSet<T> hs = new HashSet<>(list);
    list.clear();
    list.addAll(hs);
    return list;
}

3.删除List中重复元素,并保持顺序

/**
 * 删除List中重复元素,并保持顺序
 * @param list 待去重的list
 * @return 去重后的list
 */
public static <T> List<T> removeDuplicateKeepOrder(List<T> list){
    Set set = new HashSet();
    List<T> newList = new ArrayList<>();
    for (T element : list) {
        //set能添加进去就代表不是重复的元素
        if (set.add(element)) newList.add(element);
    }
    list.clear();
    list.addAll(newList);
    return list;
}

4.利用list.contain() 去重

/**
 * 利用list.contain() 去重
 * @param list
 * @return
 */
public static <T> List<T> removeDuplicateContain(List<T> list){
    List<T> listTemp = new ArrayList<>();
    for (T aList : list) {
        if (!listTemp.contains(aList)) {
            listTemp.add(aList);
        }
    }
    return listTemp;
}
<think>我们正在讨论JavaList集合方法。根据用户需求,需要展示多种方法,包括基本类型对象类型的。同时,用户提供的引用中提到了几种方法,我们可以参考并整合这些方法,同时补充其他常见方法。 注意:对于对象类型的,需要根据对象的某个属性或多个属性,这通常需要自定义比较逻辑。 我们将介绍以下几种方法: 1. 使用Stream的distinct()方法(适用于基本类型实现了equals/hashCode的对象) 2. 使用HashSet(保证顺序LinkedHashSet(保证顺序) 3. 使用TreeSet(可排序) 4. 使用迭代器遍历并利用Set判断复(保证顺序) 5. 使用Java 8的Collectors.toCollection()配合TreeSet(按属性) 6. 使用Stream配合自定义的TreeSet(按属性) 7. 使用Stream的filter()自定义的ConcurrentHashMap(按属性,保证顺序) 对于对象,我们将点展示按属性方法。 下面逐一介绍:</think>### Java List集合方法详解 在Java中,List主要有以下几种实现方式(含代码示例): #### 1. **使用Stream API(Java 8+)** ```java // 基本类型 List<String> distinctList = list.stream() .distinct() .collect(Collectors.toList()); // 对象按属性(根据name属性) List<Person> distinctPersons = personList.stream() .collect(Collectors.collectingAndThen( Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(Person::getName))), ArrayList::new)); ``` #### 2. **使用HashSet(保证顺序)** ```java Set<String> set = new HashSet<>(list); // 直接 List<String> distinctList = new ArrayList<>(set); ``` #### 3. **使用LinkedHashSet(保留顺序)** ```java Set<String> set = new LinkedHashSet<>(list); // 保留原始顺序 List<String> distinctList = new ArrayList<>(set); ``` #### 4. **迭代器遍历法(保证顺序)** ```java Set<String> set = new HashSet<>(); List<String> newList = new ArrayList<>(); for (String item : list) { if (set.add(item)) { // set.add()返回boolean判断是否已存在 newList.add(item); } } ``` #### 5. **双循环遍历(适合小数据集)** ```java for (int i = 0; i < list.size(); i++) { for (int j = i + 1; j < list.size(); j++) { if (list.get(i).equals(list.get(j))) { list.remove(j); j--; // 调整索引 } } } ``` #### 6. **对象按属性(使用TreeSet)** ```java Set<Person> set = new TreeSet<>(Comparator.comparing(Person::getId)); set.addAll(personList); List<Person> distinctList = new ArrayList<>(set); ``` #### 7. **使用Apache Commons工具类** ```java // 需添加commons-collections4依赖 ListUtils.predicatedList(list, SetUtils::predicatedSet, new HashSet<>()); ``` ### 性能对比(时间复杂度) | 方法 | 时间复杂度 | 是否保序 | 适用场景 | |--------------------|------------|----------|-----------------------| | Stream.distinct() | O(n) | 是 | Java8+简单对象 | | LinkedHashSet | O(n) | 是 | 需保序的任意对象 | | HashSet | O(n) | 否 | 无需保序的简单对象 | | TreeSet | O(n log n) | 否 | 需排序的对象属性 | | 双循环遍历 | O() | 是 | 小数据集 | > **对象关键点**: > - 基本类型直接使用`distinct()`或`Set` > - 对象需写`equals()``hashCode()`方法 > - 按属性要自定义`Comparator` > - 大数据集优先选择`HashSet`或`Stream API`方案[^1][^2]
评论 4
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值