List 去重的几种方法_list去重

前言

List 容器允许包含重复元素,但有去重的需求主要出于以下几个考虑:

减少内存占用

List 如果包含大量重复数据,会占用很多内存。去重可以减少重复数据,降低内存消耗。

提高查询效率

查询和遍历列表时,重复数据意味着无效操作,去重可以提高查询和遍历的效率。

减少计算误差

统计和聚合列表时,重复数据会导致计算结果误差。去重可以提高统计的准确性。

符合预期语义

某些场景下,列表就意味着“无重复元素的集合”,去重可以使得列表语义更清晰。

减少冗余

多个重复数据冗余度高,去重可以减少数据冗余,使数据更简洁。

提高可读性

重复数据让列表更难阅读,去重可以提高列表内容的可读性。
所以综合来说,列表去重主要是为了减少内存占用,提高查询效率,增加可读性,减少计算误差,以及更符合语义预期等目的。

---

示例

HashSet去重

对一个List进行去重,可以使用HashSet的特性来实现:

java
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;

public class Main {

  public static void main(String[] args) {
    
    List<Integer> list = new ArrayList<>();
    list.add(1);
    list.add(2); 
    list.add(2);
    list.add(3);
    list.add(3);

    // 去重过程
    HashSet<Integer> set = new HashSet<>(list);
    list.clear();
    list.addAll(set);

    // 去重后结果 
    System.out.println(list);

    // [1, 2, 3]
  }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

主要步骤是:

1. 创建一个HashSet,并使用原List初始化

2.清空原List

3.将HashSet重新添加到ListHashSet会自动过滤重复元素,实现List中的元素去重。这种方法时间复杂度为O(n),相比其他排序+去重的算法更优。

---

TreeSet去重

使用 TreeSet 来对 List 去重:

import java.util.ArrayList; 
import java.util.List;
import java.util.TreeSet;

public class Main {

  public static void main(String[] args) {
    List<Integer> list = new ArrayList<>();
    list.add(3);
    list.add(1);
    list.add(2);
    list.add(2);
    list.add(3);

    // 去重过程
    TreeSet<Integer> set = new TreeSet<>(list);  
    list.clear();
    list.addAll(set);

    // 去重后结果
    System.out.println(list);

    // [1, 2, 3]
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

主要步骤是:

1.创建一个TreeSet,传入原List进行初始化

2.清空原List

3.将TreeSet添加到ListTreeSet会自动对元素进行排序并去重,所以可以实现List的去重。

与HashSet不同,TreeSet是有序的,所以去重后的List顺序与原List不同。时间复杂度也是O(n),但HashSet效率略高一些。

所以根据需要采用HashSet或TreeSet进行去重都可以。

---

LinkedHashSet去重

使用 LinkedHashSet 来对 List 去重,同时保持元素的插入顺序:

import java.util.ArrayList;
import java.util.LinkedHashSet; 
import java.util.List;

public class Main {

  public static void main(String[] args) {
    List<Integer> list = new ArrayList<>();
    list.add(3); 
    list.add(1);
    list.add(2);
    list.add(2); 
    list.add(3);

    // 去重过程
    LinkedHashSet<Integer> set = new LinkedHashSet<>(list); 
    list.clear();
    list.addAll(set);

    // 去重后结果
    System.out.println(list);

    // [3, 1, 2]
  }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

主要步骤是:

1. 创建一个LinkedHashSet,传入原List进行初始化

2. 清空原List

3. 将LinkedHashSet添加到ListLinkedHashSet可以保持元素的插入顺序,同时自动去重。

所以使用它可以保持List元素顺序的同时去除重复元素。时间复杂度也是O(n),但比HashSet稍慢一些。适合需要保持顺序的去重场景。

---

迭代器去重

要使用迭代器去重，可以使用Set集合来过滤重复元素。下面是一个简单的示例代码：

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class IteratorDemo {
    public static void main(String[] args) {
        // 创建一个包含重复元素的集合
        Set<Integer> set = new HashSet<>();
        set.add(1);
        set.add(2);
        set.add(1);
        set.add(3);
        set.add(2);
        
        // 创建迭代器
        Iterator<Integer> iterator = set.iterator();
        
        // 遍历并输出不重复的元素
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

运行该代码，输出结果只包含不重复的元素：1、2和3。这是因为Set集合会自动过滤重复元素，保证集合中的元素唯一性。

通过迭代器遍历Set集合，你可以获取到不重复的元素并进行进一步的操作。

---

Stream去重

使用Stream API来对集合进行去重操作。下面是一个示例代码：

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
    List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 4, 5, 6, 6, 7, 8, 8, 9, 10);

    List<Integer> distinctNumbers = numbers.stream()
    .distinct()
    .collect(Collectors.toList());

    System.out.println(distinctNumbers);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

主要步骤是:

1.创建了一个包含重复元素的整数列表。

2.我们使用stream()方法将列表转换为流。

3.使用distinct()方法对流进行去重操作。

4.我们使用collect()方法将去重后的元素收集到一个新的列表中。

输出将是[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]，即去除了重复元素的列表。

---

contains去重

下面是一个示例代码：

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

public class Main {
    public static void main(String[] args) {
    List<Integer> numbers = new ArrayList<>();
    numbers.add(1);
    numbers.add(2);
    numbers.add(3);
    numbers.add(4);
    numbers.add(4);
    numbers.add(5);
    numbers.add(6);
    numbers.add(6);
    numbers.add(7);
    numbers.add(8);
    numbers.add(8);
    numbers.add(9);
    numbers.add(10);

    Set<Integer> distinctNumbers = new HashSet<>(numbers);

    System.out.println(distinctNumbers);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

主要步骤是:

1.创建了一个包含重复元素的整数列表。

2.创建了一个空的HashSet集合，并将列表中的元素添加到集合中。由于HashSet不允许重复元素，重复的元素将被自动去重。

3.我们打印出去重后的元素。

输出将是[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]，即去除了重复元素的集合。

---

常见使用场景

1. 数据清洗：

   在数据分析和处理过程中，经常需要对数据进行去重操作，以确保数据的准确性和一致性。

2. 重复项检测：

   在文本处理中，可以使用list去重来检测和删除重复的句子、短语或单词，以提高文本处理的效率和质量。

3. 用户管理：

   在用户管理系统中，可以使用list去重来确保每个用户的唯一性，避免重复创建相同的用户账号。

4. 商品去重：

   在电商平台中，可以使用list去重来检测和删除重复的商品信息，以提供更好的购物体验和准确的商品推荐。

5. 社交媒体分析：

   在社交媒体数据分析中，可以使用list去重来识别和删除重复的帖子、评论或用户，以获得更准确的分析结果。

6. 数据库管理：

   在数据库管理中，可以使用list去重来确保数据库中的记录唯一性，避免重复插入相同的数据。

---

写在最后

感谢您的支持和鼓励！