java中list如何去重

Java中去重List的方法包括使用Set、使用Java 8的Stream API、自定义去重方法。其中，最常用且高效的方法是使用Set来去重。具体方法如下：

使用Set来去重
使用Java 8的Stream API来去重
自定义去重方法

下面详细介绍每种方法的具体实现以及它们的优缺点。

一、使用Set来去重

1.1 为什么使用Set

Set是Java集合框架中一个非常重要的接口，它的特点是不允许包含重复的元素。因此，使用Set来去重是一种非常简单且高效的方法。

1.2 使用HashSet去重

HashSet是Set接口的一个实现类，它通过哈希表来存储元素，具有很高的查找和插入效率。

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
public class RemoveDuplicatesUsingSet {
    public static void main(String[] args) {
        List<String> listWithDuplicates = new ArrayList<>();
        listWithDuplicates.add("apple");
        listWithDuplicates.add("banana");
        listWithDuplicates.add("apple");
        listWithDuplicates.add("orange");
        Set<String> set = new HashSet<>(listWithDuplicates);
        List<String> listWithoutDuplicates = new ArrayList<>(set);
        System.out.println("List with duplicates: " + listWithDuplicates);
        System.out.println("List without duplicates: " + listWithoutDuplicates);
    }
}

优点：

简单易用，代码简洁。
执行效率高。

缺点：

无法保证原List的元素顺序，因为HashSet不维护插入顺序。

1.3 使用LinkedHashSet去重

如果需要保留原List的元素顺序，可以使用LinkedHashSet，它是HashSet的子类，且维护了元素的插入顺序。

import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
public class RemoveDuplicatesUsingLinkedHashSet {
    public static void main(String[] args) {
        List<String> listWithDuplicates = new ArrayList<>();
        listWithDuplicates.add("apple");
        listWithDuplicates.add("banana");
        listWithDuplicates.add("apple");
        listWithDuplicates.add("orange");
        Set<String> set = new LinkedHashSet<>(listWithDuplicates);
        List<String> listWithoutDuplicates = new ArrayList<>(set);
        System.out.println("List with duplicates: " + listWithDuplicates);
        System.out.println("List without duplicates: " + listWithoutDuplicates);
    }
}

优点：

保留原List的元素顺序。
执行效率较高。

缺点：

相对HashSet略微增加了内存开销，因为需要维护元素的插入顺序。

二、使用Java 8的Stream API来去重

Java 8引入了Stream API，它提供了一种声明性的方法来处理集合数据。使用Stream API可以非常方便地去重。

2.1 使用distinct()方法

distinct()方法是Stream接口的一部分，它返回一个由该流的不同元素（根据Object.equals(Object)）组成的流。

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class RemoveDuplicatesUsingStream {
    public static void main(String[] args) {
        List<String> listWithDuplicates = new ArrayList<>();
        listWithDuplicates.add("apple");
        listWithDuplicates.add("banana");
        listWithDuplicates.add("apple");
        listWithDuplicates.add("orange");
        List<String> listWithoutDuplicates = listWithDuplicates.stream()
                .distinct()
                .collect(Collectors.toList());
        System.out.println("List with duplicates: " + listWithDuplicates);
        System.out.println("List without duplicates: " + listWithoutDuplicates);
    }
}

优点：

代码简洁、易读。
保留原List的元素顺序。

缺点：

相对Set的实现，执行效率可能略低，尤其是对于大型数据集。

2.2 使用Collectors.toSet()方法

Stream API还提供了另一种去重的方法，即通过Collectors.toSet()方法将流中的元素收集到一个Set中。

import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
public class RemoveDuplicatesUsingCollectorsToSet {
    public static void main(String[] args) {
        List<String> listWithDuplicates = new ArrayList<>();
        listWithDuplicates.add("apple");
        listWithDuplicates.add("banana");
        listWithDuplicates.add("apple");
        listWithDuplicates.add("orange");
        Set<String> set = listWithDuplicates.stream()
                .collect(Collectors.toSet());
        List<String> listWithoutDuplicates = new ArrayList<>(set);
        System.out.println("List with duplicates: " + listWithDuplicates);
        System.out.println("List without duplicates: " + listWithoutDuplicates);
    }
}

优点：

代码简洁、易读。
执行效率较高。

缺点：

无法保证原List的元素顺序，因为Set不维护插入顺序。

三、自定义去重方法

在某些特殊情况下，我们可能需要自定义去重逻辑。这时可以通过遍历List并手动去重。

3.1 使用for循环和contains()方法

我们可以使用for循环遍历List，并使用contains()方法检查是否已经存在于新List中，如果不存在则添加。

import java.util.ArrayList;
import java.util.List;
public class RemoveDuplicatesUsingCustomMethod {
    public static void main(String[] args) {
        List<String> listWithDuplicates = new ArrayList<>();
        listWithDuplicates.add("apple");
        listWithDuplicates.add("banana");
        listWithDuplicates.add("apple");
        listWithDuplicates.add("orange");
        List<String> listWithoutDuplicates = new ArrayList<>();
        for (String item : listWithDuplicates) {
            if (!listWithoutDuplicates.contains(item)) {
                listWithoutDuplicates.add(item);
            }
        }
        System.out.println("List with duplicates: " + listWithDuplicates);
        System.out.println("List without duplicates: " + listWithoutDuplicates);
    }
}

优点：

可根据需要自定义去重逻辑。
保留原List的元素顺序。

缺点：

代码较为冗长。
对于大型数据集，执行效率较低，因为contains()方法的时间复杂度为O(n)。

3.2 使用Map来去重

我们还可以使用Map来去重，通过将List的元素作为Map的键，利用Map键的唯一性来去重。

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
public class RemoveDuplicatesUsingMap {
    public static void main(String[] args) {
        List<String> listWithDuplicates = new ArrayList<>();
        listWithDuplicates.add("apple");
        listWithDuplicates.add("banana");
        listWithDuplicates.add("apple");
        listWithDuplicates.add("orange");
        Map<String, Boolean> map = new LinkedHashMap<>();
        for (String item : listWithDuplicates) {
            map.put(item, Boolean.TRUE);
        }
        List<String> listWithoutDuplicates = new ArrayList<>(map.keySet());
        System.out.println("List with duplicates: " + listWithDuplicates);
        System.out.println("List without duplicates: " + listWithoutDuplicates);
    }
}

优点：

保留原List的元素顺序。
执行效率较高。

缺点：

代码相对复杂，增加了内存开销。

四、性能对比与选择

4.1 性能对比

Set的实现（如HashSet、LinkedHashSet）：执行效率较高，适合大多数情况。
Stream API：代码简洁、易读，适合中小规模数据集。
自定义方法：灵活性高，但对于大型数据集执行效率较低。

4.2 选择建议

对于大多数常见情况，推荐使用Set（尤其是LinkedHashSet如果需要保持顺序）。
如果代码的可读性和简洁性是首要考虑因素，推荐使用Stream API。
在需要复杂自定义去重逻辑的情况下，可以考虑使用自定义方法。

总之，根据具体需求选择合适的方法进行List去重，是Java开发中常见且重要的一个技能。无论是使用Set、Stream API还是自定义方法，都各有优劣，关键在于根据实际场景做出最优选择。