如何去除List集合中的重复元素?

一、问题由来

在实际开发的时候，我们经常会碰到这么一个问题：一个集合容器里面有很多重复的对象，里面的对象没有主键，或者说忽略主键，根据业务的需求，我们需要根据条件筛选出没有重复的对象。

二、去重操作

1.通过两层循环去重

通过两层循环来进行判断，没有重复的元素就加入到新集合中，新集合中已经有的元素就跳过。

实体类使用Lombok注解，推荐阅读：Lombok使用指南

实体：

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Animal {

    private String category;            // 类别

    private String species;             // 种类

}

测试：

public static void main(String[] args) {
        // 添加信息，Animal中没有主键
        List<Animal> animalList = new ArrayList<Animal>();
        animalList.add(new Animal("犬科","狗"));
        animalList.add(new Animal("犬科","狗"));
        animalList.add(new Animal("犬科","狗"));
        animalList.add(new Animal("犬科","狼"));
        animalList.add(new Animal("猫科","猫"));
        animalList.add(new Animal("猫科","豹"));

        // 新数据集合
        List<Animal> newAnimalList = new ArrayList<Animal>();
        // 传统重复判断
        for (Animal animal : animalList) {
            if(newAnimalList.isEmpty()){
                newAnimalList.add(animal);
            }else{
                boolean isSame = false;
                for (Animal newAnimal : newAnimalList) {
                    // 如果新集合包含元素，直接跳过
                    if(animal.getCategory().equals(newAnimal.getCategory()) && animal.getSpecies().equals(newAnimal.getSpecies())){
                        isSame = true;
                        break;
                    }
                }
                if(!isSame){
                    newAnimalList.add(animal);
                }
            }
        }

        // 输出结果
        for (Animal animal : newAnimalList) {
            System.out.println(animal.toString());
        }
    }

输出结果：

Animal(category=犬科, species=狗)
Animal(category=犬科, species=狼)
Animal(category=猫科, species=猫)
Animal(category=猫科, species=豹)

一般处理数组类型的对象时，可以通过这种方法来对数组元素进行去重操作，以筛选出没有包含重复元素的数组。

2.利用list中contains()方法去重

在使用contains()之前，必须要对Animal类重写equals()方法，如果Animal对象不重写equals()，contains()方法的都是false！新数据与源数据是一样的，并不能达到我们想要除去重复元素的目的。

那么contains()是怎么做到，判断一个集合里面有相同的元素呢？

我们打开ArrayList中contains()方法，源码如下：

public boolean contains(Object o) {
    return indexOf(o) >= 0;
}

找到indexOf(o)方法，源码如下：

public int indexOf(Object o) {
    if (o == null) {
        for (int i = 0; i < size; i++)
            if (elementData[i]==null)
                return i;
    } else {
        for (int i = 0; i < size; i++)
           //对象通过 equals 方法，判断是否相同
            if (o.equals(elementData[i]))
                return i;
    }
    return -1;
}

如果传入的对象是null，for循环判断数组中的元素是否有null，如果有就返回下标；如果传入的对象不是null，通过对象的equals()方法，for循环判断是否有相同的元素，如果有就返回下标！

如果是数组返回的下标，肯定是大于0，否则返回-1！

这就是为什么在List中使用contains()方法，对象需要重写equals()方法的原因！

重写equals():

@Override
public boolean equals(Object o) {
    if (this == o) {
        return true;
    }
    if (o == null || getClass() != o.getClass()) {
        return false;
    }
    Animal animal = (Animal) o;
    // 当category、species 内容都相等的时候，才返回true
    return Objects.equals(category, animal.category) && Objects.equals(species, animal.species);
}

测试：

public static void main(String[] args) {
        // 添加信息，Animal中没有主键
        List<Animal> animalList = new ArrayList<Animal>();
        animalList.add(new Animal("犬科","狗"));
        animalList.add(new Animal("犬科","狗"));
        animalList.add(new Animal("犬科","狗"));
        animalList.add(new Animal("犬科","狼"));
        animalList.add(new Animal("猫科","猫"));
        animalList.add(new Animal("猫科","豹"));

        // 新数据集合
        List<Animal> newAnimalList = new ArrayList<Animal>();
        // 使用contain判断，是否有相同的元素
        for (Animal animal: animalList) {
            if(!newAnimalList.contains(animal)){
                newAnimalList.add(animal);
            }
        }

        // 输出结果
        for (Animal animal : newAnimalList) {
            System.out.println(animal.toString());
        }
    }

输出结果：

Animal(category=犬科, species=狗)
Animal(category=犬科, species=狼)
Animal(category=猫科, species=猫)
Animal(category=猫科, species=豹)

3.使用java 8中的Stream.distinct()去重

使用JDK1.8 中的流式写法，利用 jdk1.8 中提供的Stream.distinct()列表去重，Stream.distinct()使用hashCode()和equals()方法来获取不同的元素，因此使用这种写法，对象需要重写hashCode()和equals()方法！

重写hashCode()方法：

@Override
public int hashCode() {
    return Objects.hash(category, category);
}

测试：

public static void main(String[] args) {
        // 添加信息，Animal中没有主键
        List<Animal> animalList = new ArrayList<Animal>();
        animalList.add(new Animal("犬科","狗"));
        animalList.add(new Animal("犬科","狗"));
        animalList.add(new Animal("犬科","狗"));
        animalList.add(new Animal("犬科","狼"));
        animalList.add(new Animal("猫科","猫"));
        animalList.add(new Animal("猫科","豹"));

        //使用java8新特性stream进行List去重
        List<Animal> newAnimalList = animalList.stream().distinct().collect(Collectors.toList());

        // 输出结果
        for (Animal animal : newAnimalList) {
            System.out.println(animal.toString());
        }

    }

输出结果：

Animal(category=犬科, species=狗)
Animal(category=犬科, species=狼)
Animal(category=猫科, species=猫)
Animal(category=猫科, species=豹)

4.利用HashSet去重

HashSet集合天然支持元素不重复！需要同时重写Object中的equals()和hashCode()方法

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Animal {

    private String category;            // 类别

    private String species;             // 种类

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        Animal animal = (Animal) o;
        // 当category、species 内容都相等的时候，才返回true
        return Objects.equals(category, animal.category) && Objects.equals(species, animal.species);
    }

    @Override
    public int hashCode() {
        return Objects.hash(category, category);
    }

}

测试：

public static void main(String[] args) {
        // 添加信息，Animal中没有主键
        List<Animal> animalList = new ArrayList<Animal>();
        animalList.add(new Animal("犬科","狗"));
        animalList.add(new Animal("犬科","狗"));
        animalList.add(new Animal("犬科","狗"));
        animalList.add(new Animal("犬科","狼"));
        animalList.add(new Animal("猫科","猫"));
        animalList.add(new Animal("猫科","豹"));

        // 新数据集合
        List<Animal> newAnimalList = new ArrayList<Animal>();
        //set去重
        HashSet<Animal> set = new HashSet<>(animalList);
        newAnimalList.addAll(set);

        // 输出结果
        for (Animal animal : newAnimalList) {
            System.out.println(animal.toString());
        }

    }

输出结果：

Animal(category=犬科, species=狗)
Animal(category=犬科, species=狼)
Animal(category=猫科, species=猫)
Animal(category=猫科, species=豹)

打开HashSet的源码，查看我们传入的构造方法如下：

public HashSet(Collection<? extends E> c) {
    map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
    addAll(c);
}

首先创建了一个HashMap对象，然后调用addAll()方法

public boolean addAll(Collection<? extends E> c) {
    boolean modified = false;
    for (E e : c)
        if (add(e))
            modified = true;
    return modified;
}

首先遍历List中的元素，然后调用add()方法，这个方法，源码如下：

public boolean add(E e) {
    return map.put(e, PRESENT)==null;
}

其实，就是向HashMap对象中插入元素，其中PRESENT是一个new Object()常量！

private static final Object PRESENT = new Object();

到这里就基本很清楚了，向HashSet中添加元素，其实等同于

Map<Object,Object> map = new HashMap<Object,Object>();
map.put(e,new Object);//e表示要插入的元素

其中插入的元素e，就是HashMap中的key！

我们知道HashMap，是通过equals()和hashCode()来判断插入的key是否为同一个key，因此，当我们对Animal对象进行重写equals()和hashCode()时，保证判断是同一个key时，就可以达到元素去重的目的！

最后，对已经去重的集合HashSet，再通过ArrayList中的addAll()方法进行包装，即可得到我们想要的不包含重复元素的数据！