面试官提问:如何去掉List集合中重复的元素?

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

本文转载自微信公众号「Java极客技术」,作者鸭血粉丝。转载本文请联系Java极客技术公众号。

 一、问题由来

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

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

操作例子如下,创建一个实体对象PenBean,代码如下:

/** 
 * 笔实体 
 */ 
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 + '\'' + 
                '}'
    } 

  • 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.

测试 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()); 
    } 

  • 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.
  • 29.
  • 30.
  • 31.
  • 32.
  • 33.
  • 34.
  • 35.
  • 36.
  • 37.

输出结果:

=========新数据====== 
PenBean{type='铅笔', color='black'
PenBean{type='铅笔', color='white'
PenBean{type='中性笔', color='white'
  • 1.
  • 2.
  • 3.
  • 4.

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

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

答案肯定是有的,List中的contains()方法就是!

二、利用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); 

  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.

修改测试 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()); 
    } 

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

输出结果如下:

=========新数据====== 
PenBean{type='铅笔', color='black'
PenBean{type='铅笔', color='white'
PenBean{type='中性笔', color='white'
  • 1.
  • 2.
  • 3.
  • 4.

如果PenBean对象不重写equals(),contains()方法的都是false!新数据与源数据是一样的,并不能达到我们想要除去重复元素的目的

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

我们打开ArrayList中contains()方法,源码如下:

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

  • 1.
  • 2.
  • 3.

找到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; 

  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.

此时,非常清晰了,如果传入的对象是null,for循环判断数组中的元素是否有null,如果有就返回下标;如果传入的对象不是null,通过对象的equals()方法,for循环判断是否有相同的元素,如果有就返回下标!

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

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

三、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()); 
    } 

  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.

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

对PenBean对象重写hashCode()方法,代码如下:

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

  • 1.
  • 2.
  • 3.
  • 4.

在运行测试demo,结果如下:

=========新数据====== 
PenBean{type='铅笔', color='black'
PenBean{type='铅笔', color='white'
PenBean{type='中性笔', color='white'
  • 1.
  • 2.
  • 3.
  • 4.

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

那为什么当我们使用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; 


  • 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.
  • 29.
  • 30.
  • 31.
  • 32.
  • 33.
  • 34.
  • 35.
  • 36.
  • 37.
  • 38.
  • 39.
  • 40.

四、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); 
 } 
   

  • 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.
  • 29.
  • 30.
  • 31.
  • 32.
  • 33.
  • 34.
  • 35.
  • 36.
  • 37.

创建测试 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()); 
    } 

  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.

输出结果如下:

=========新数据====== 
PenBean{type='铅笔', color='white'
PenBean{type='铅笔', color='black'
PenBean{type='中性笔', color='white'
  • 1.
  • 2.
  • 3.
  • 4.

很明细,返回的新集合没有重复元素!

那HashSet是怎么做的的呢?

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

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

  • 1.
  • 2.
  • 3.
  • 4.

很显然,首先创建了一个HashMap对象,然后调用addAll()方法,继续往下看这个方法!

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

  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.

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

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

  • 1.
  • 2.
  • 3.

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

private static final Object PRESENT = new Object(); 
  • 1.

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

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

其中插入的元素e,就是HashMap中的key!

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

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

 

责任编辑:武晓燕 来源: Java极客技术
相关推荐

2021-12-15 06:58:13

List 集合LinkedHashS

2021-12-21 07:07:43

HashSet元素数量

2022-09-29 07:30:57

数据库索引字段

2021-12-08 06:53:29

面试动态代理

2020-09-30 06:49:25

MySQL查询删除

2024-10-29 08:17:43

2015-08-13 10:29:12

面试面试官

2020-08-17 07:40:19

消息队列

2023-10-12 07:35:45

面试线程通信

2010-08-12 16:28:35

面试官

2023-02-16 08:10:40

死锁线程

2024-10-15 10:00:06

2021-10-14 06:51:55

数据库SQL

2024-06-18 14:08:22

2024-09-11 22:51:19

线程通讯Object

2024-04-03 00:00:00

Redis集群代码

2021-07-06 07:08:18

管控数据数仓

2023-11-20 10:09:59

2024-03-18 14:06:00

停机Spring服务器

2024-02-20 14:10:55

系统缓存冗余
点赞
收藏

51CTO技术栈公众号