List 集合去重的 3 种方法

绝地灬酷狼 2023-10-05 08:39 39阅读 0赞

![format_png][]

### 问题由来 ###

在实际开发的时候，我们经常会碰到这么一个困难：**一个集合容器里面有很多重复的对象，里面的对象没有主键，但是根据业务的需求，实际上我们需要根据条件筛选出没有重复的对象**。

比较暴力的方法，就是根据业务需求，通过两层循环来进行判断，没有重复的元素就加入到新集合中，新集合中已经有的元素就跳过。

操作例子如下，创建一个实体对象`PenBean`，代码如下：

测试 demo，如下：

public static void main(String[] args) {
        //添加信息，PenBean中没有主键
        List<PenBean> penBeanList = new ArrayList<PenBean>();
        penBeanList.add(new PenBean("铅笔","black"));
        penBeanList.add(new PenBean("铅笔","white"));
        penBeanList.add(new PenBean("铅笔","black"));
        penBeanList.add(new PenBean("中性笔","white"));
        penBeanList.add(new PenBean("中性笔","white"));
    
        //新数据
        List<PenBean> newPenBeanList = new ArrayList<PenBean>();
        //传统重复判断
        for (PenBean penBean : penBeanList) {
            if(newPenBeanList.isEmpty()){
                newPenBeanList.add(penBean);
            }else{
                boolean isSame = false;
                for (PenBean newPenBean : newPenBeanList) {
                    //依靠type、color来判断，是否有重复元素
                    //如果新集合包含元素，直接跳过
                    if(penBean.getType().equals(newPenBean.getType()) && penBean.getColor().equals(newPenBean.getColor())){
                        isSame = true;
                        break;
                    }
                }
                if(!isSame){
                    newPenBeanList.add(penBean);
                }
            }
        }
    
        //输出结果
        System.out.println("=========新数据======");
        for (PenBean penBean : newPenBeanList) {
            System.out.println(penBean.toString());
        }
    }

输出结果：

=========新数据======
    PenBean{type='铅笔', color='black'}
    PenBean{type='铅笔', color='white'}
    PenBean{type='中性笔', color='white'}

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

那有没有更加简洁的写法呢？

答案肯定是有的，**`List`中的`contains()`方法就是！**

### 1、利用list中contains方法去重 ###

在使用`contains()`之前，必须要对`PenBean`类重写`equals()`方法，为什么要这么做？等会会详细解释！

我们先在`PenBean`类中重写`equals()`方法，内容如下：

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

修改测试 demo，如下：

public static void main(String[] args) {
        //添加信息
        List<PenBean> penBeanList = new ArrayList<PenBean>();
        penBeanList.add(new PenBean("铅笔","black"));
        penBeanList.add(new PenBean("铅笔","white"));
        penBeanList.add(new PenBean("铅笔","black"));
        penBeanList.add(new PenBean("中性笔","white"));
        penBeanList.add(new PenBean("中性笔","white"));
    
        //新数据
        List<PenBean> newPenBeanList = new ArrayList<PenBean>();
        //使用contain判断，是否有相同的元素
        for (PenBean penBean : penBeanList) {
            if(!newPenBeanList.contains(penBean)){
                newPenBeanList.add(penBean);
            }
        }
    
        //输出结果
        System.out.println("=========新数据======");
        for (PenBean penBean : newPenBeanList) {
            System.out.println(penBean.toString());
        }
    }

输出结果如下：

=========新数据======
    PenBean{type='铅笔', color='black'}
    PenBean{type='铅笔', color='white'}
    PenBean{type='中性笔', color='white'}

**如果`PenBean`对象不重写`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()`方法的原因！

### 2、java 8中去重操作 ###

当然，有些朋友可能会想到 JDK1.8 中的流式写法，例如 jdk1.8 中的集合元素去重写法如下：

public static void main(String[] args) {
        //添加信息
        List<PenBean> penBeanList = new ArrayList<PenBean>();
        penBeanList.add(new PenBean("铅笔","black"));
        penBeanList.add(new PenBean("铅笔","white"));
        penBeanList.add(new PenBean("铅笔","black"));
        penBeanList.add(new PenBean("中性笔","white"));
        penBeanList.add(new PenBean("中性笔","white"));
    
        //使用java8新特性stream进行List去重
        List<PenBean> newPenBeanList = penBeanList.stream().distinct().collect(Collectors.toList());
    
        //输出结果
        System.out.println("=========新数据======");
        for (PenBean penBean : newPenBeanList) {
            System.out.println(penBean.toString());
        }
    }

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

对`PenBean`对象重写`hashCode()`方法，代码如下：

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

在运行测试demo，结果如下：

=========新数据======
    PenBean{type='铅笔', color='black'}
    PenBean{type='铅笔', color='white'}
    PenBean{type='中性笔', color='white'}

**即可实现集合元素的去重操作！**

那为什么当我们使用`String`类型的对象作为集合元素时，没有重写呢？

因为 java 中`String`原生类，已经重写好了，源码如下：

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
     
     @Override
     public boolean equals(Object anObject) {
            if (this == anObject) {
                return true;
            }
            if (anObject instanceof String) {
                String anotherString = (String)anObject;
                int n = value.length;
                if (n == anotherString.value.length) {
                    char v1[] = value;
                    char v2[] = anotherString.value;
                    int i = 0;
                    while (n-- != 0) {
                        if (v1[i] != v2[i])
                            return false;
                        i++;
                    }
                    return true;
                }
            }
            return false;
        }
     
     @Override
     public int hashCode() {
        int h = hash;
        if (h == 0 && value.length > 0) {
            char val[] = value;
    
            for (int i = 0; i < value.length; i++) {
                h = 31 * h + val[i];
            }
            hash = h;
        }
        return h;
    }
    }

### 3、HashSet去重操作 ###

在上面的分享中，我们介绍了 List 的集合去重操作！其中网友还提到了`HashSet`可以实现元素的去重！

的确，`HashSet`集合天然支持元素不重复！

实践代码如下！

还是先创建一个对象`PenBean`，同时重写`Object`中的`equals()`和`hashCode()`方法，如下：

/**
     * 笔实体
     */
    public class PenBean {
        /**类型*/
        private String type;
        /**颜色*/
        private String color;
        //... 省略 setter 和 getter
        public PenBean(String type, String color) {
            this.type = type;
            this.color = color;
        }
        @Override
        public String toString() {
            return "PenBean{" +
                    "type='" + type + '\'' +
                    ", color='" + color + '\'' +
                    '}';
        }
     
     @Override
     public boolean equals(Object o) {
          if (this == o) return true;
          if (o == null || getClass() != o.getClass()) return false;
          PenBean penBean = (PenBean) o;
          //当type、color 内容都相等的时候，才返回true
          return Objects.equals(type, penBean.type) &&
              Objects.equals(color, penBean.color);
     }
     
     @Override
     public int hashCode() {
        return Objects.hash(type, color);
     }
      
    }

创建测试 demo，如下：

public static void main(String[] args) {
        //添加信息
        List<PenBean> penBeanList = new ArrayList<PenBean>();
        penBeanList.add(new PenBean("铅笔","black"));
        penBeanList.add(new PenBean("铅笔","white"));
        penBeanList.add(new PenBean("铅笔","black"));
        penBeanList.add(new PenBean("中性笔","white"));
        penBeanList.add(new PenBean("中性笔","white"));
    
        //新数据
        List<PenBean> newPenBeanList = new ArrayList<PenBean>();
        //set去重
        HashSet<PenBean> set = new HashSet<>(penBeanList);
        newPenBeanList.addAll(set);
    
        //输出结果
        System.out.println("=========新数据======");
        for (PenBean penBean : newPenBeanList) {
            System.out.println(penBean.toString());
        }
    }

输出结果如下：

=========新数据======
    PenBean{type='铅笔', color='white'}
    PenBean{type='铅笔', color='black'}
    PenBean{type='中性笔', color='white'}

很明细，返回的新集合没有重复元素！

那`HashSet`是怎么做的的呢？

打开`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`**，因此，当我们对`PenBean`对象进行重写`equals()`和`hashCode()`时，保证判断是同一个`key`时，就可以达到元素去重的目的！

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

### 最后 ###

**你还知道哪些集合去重的方法，欢迎评论区留言补充~**

往期推荐

[![format_png 1][]][format_png 1 1]

[阿里《Java开发手册》最新嵩山版发布！][format_png 1 1]

[![format_png 2][]][format_png 2 1]

[最简单的6种防止数据重复提交的方法！(干货)][format_png 2 1]

关注下方二维码，每一天都有干货！

![format_png 3][]

[format_png]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X2pwZy9Icld3Nlp1WENzaWFLQU51VFlLa2gzenVwVUk5RFNnMEZ1Tzlkak1rWVA1RGliVDgzaldXeGljTEJGMk9pYXdEN1ZBVUJLRXhodUJaaWNFMlVWbDc4ZzNQVUxRLzY0MA?x-oss-process=image/format,png
[format_png 1]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X2pwZy9Icld3Nlp1WENzaWFSU0NNV000Q3R6djRCbDFuOE9adUNjQnhkS0pQRjE2VktRTWh4NlhCWEI0OWhyeW5wbkkxR3dxWWJOZGlhN20yalJoMUZDbjJLaWFVZy82NDA?x-oss-process=image/format,png
[format_png 1 1]: http://mp.weixin.qq.com/s?__biz=MzU1NTkwODE4Mw%3D%3D&chksm=fbcc7da5ccbbf4b30dfc048032a272764145fbd71008e132316eaa79f4fe11575f5ae22b8f1a&idx=1&mid=2247487645&scene=21&sn=3d60fe2de44eac0e66e80725e0c34240#wechat_redirect
[format_png 2]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X2pwZy9Icld3Nlp1WENzakdMVExYYlBUVkwydWJFOFd1bWRsbTViNm9zMEVXSFZvWlhvUWJpY3J6d0NYb3QxWlU3bVhpY0lFbWpmOWZlaWNSb0Ewb2hvSXZXRmh2Zy82NDA?x-oss-process=image/format,png
[format_png 2 1]: http://mp.weixin.qq.com/s?__biz=MzU1NTkwODE4Mw%3D%3D&chksm=fbcc624eccbbeb58834ce14306465b52bfc2a172f3b65eeb3a8b272bf88aa2bff0971f2e4604&idx=1&mid=2247487350&scene=21&sn=d1c2cb1c63f0ef40b2de623fe8589486#wechat_redirect
[format_png 3]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X2pwZy9zWnlBSnRpYWVzV2NqajRZNmIyUnNZampPNGNtc0E3OXZKY2RyY080RDZxb2t6V1l6NjQ4S2ZQVFNsSWhCeWVKbGZzQmtLaWFzWHR4a2JSTFRUSUxRcGlidy82NDA?x-oss-process=image/format,png