文章详情

登录

短信预约-IT技能 免费直播动态提醒

选择考试省份

  • 北京
  • 上海
  • 天津
  • 重庆
  • 河北
  • 山东
  • 辽宁
  • 黑龙江
  • 吉林
  • 甘肃
  • 青海
  • 河南
  • 江苏
  • 湖北
  • 湖南
  • 江西
  • 浙江
  • 广东
  • 云南
  • 福建
  • 海南
  • 山西
  • 四川
  • 陕西
  • 贵州
  • 安徽
  • 广西
  • 内蒙
  • 西藏
  • 新疆
  • 宁夏
  • 兵团

请输入下面的图形验证码

提交验证

短信预约提醒成功

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

2024-12-11 16:44

关注

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

 一、问题由来

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

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

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

  1.  
  2. public class PenBean { 
  3.  
  4.      
  5.     private String type; 
  6.  
  7.      
  8.     private String color; 
  9.  
  10.     //... 省略 setter 和 getter 
  11.  
  12.     public PenBean(String type, String color) { 
  13.         this.type = type; 
  14.         this.color = color; 
  15.     } 
  16.  
  17.     @Override 
  18.     public String toString() { 
  19.         return "PenBean{" + 
  20.                 "type='" + type + '\'' + 
  21.                 ", color='" + color + '\'' + 
  22.                 '}'; 
  23.     } 
  24. } 

测试 demo，如下：

  1. public static void main(String[] args) { 
  2.     //添加信息，PenBean中没有主键 
  3.     List penBeanList = new ArrayList(); 
  4.     penBeanList.add(new PenBean("铅笔","black")); 
  5.     penBeanList.add(new PenBean("铅笔","white")); 
  6.     penBeanList.add(new PenBean("铅笔","black")); 
  7.     penBeanList.add(new PenBean("中性笔","white")); 
  8.     penBeanList.add(new PenBean("中性笔","white")); 
  9.  
  10.     //新数据 
  11.     List newPenBeanList = new ArrayList(); 
  12.     //传统重复判断 
  13.     for (PenBean penBean : penBeanList) { 
  14.         if(newPenBeanList.isEmpty()){ 
  15.             newPenBeanList.add(penBean); 
  16.         }else{ 
  17.             boolean isSame = false; 
  18.             for (PenBean newPenBean : newPenBeanList) { 
  19.                 //依靠type、color来判断，是否有重复元素 
  20.                 //如果新集合包含元素，直接跳过 
  21.                 if(penBean.getType().equals(newPenBean.getType()) && penBean.getColor().equals(newPenBean.getColor())){ 
  22.                     isSame = true; 
  23.                     break; 
  24.                 } 
  25.             } 
  26.             if(!isSame){ 
  27.                 newPenBeanList.add(penBean); 
  28.             } 
  29.         } 
  30.     } 
  31.  
  32.     //输出结果 
  33.     System.out.println("=========新数据======"); 
  34.     for (PenBean penBean : newPenBeanList) { 
  35.         System.out.println(penBean.toString()); 
  36.     } 
  37. } 

输出结果：

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

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

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

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

二、利用list中contains方法去重

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

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

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

修改测试 demo，如下：

  1. public static void main(String[] args) { 
  2.     //添加信息 
  3.     List penBeanList = new ArrayList(); 
  4.     penBeanList.add(new PenBean("铅笔","black")); 
  5.     penBeanList.add(new PenBean("铅笔","white")); 
  6.     penBeanList.add(new PenBean("铅笔","black")); 
  7.     penBeanList.add(new PenBean("中性笔","white")); 
  8.     penBeanList.add(new PenBean("中性笔","white")); 
  9.  
  10.     //新数据 
  11.     List newPenBeanList = new ArrayList(); 
  12.     //使用contain判断，是否有相同的元素 
  13.     for (PenBean penBean : penBeanList) { 
  14.         if(!newPenBeanList.contains(penBean)){ 
  15.             newPenBeanList.add(penBean); 
  16.         } 
  17.     } 
  18.  
  19.     //输出结果 
  20.     System.out.println("=========新数据======"); 
  21.     for (PenBean penBean : newPenBeanList) { 
  22.         System.out.println(penBean.toString()); 
  23.     } 
  24. } 

输出结果如下：

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

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

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

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

  1. public boolean contains(Object o) { 
  2.     return indexOf(o) >= 0; 
  3. } 

找到indexOf(o)方法，继续往下看，源码如下：

  1. public int indexOf(Object o) { 
  2.     if (o == null) { 
  3.         for (int i = 0; i < size; i++) 
  4.             if (elementData[i]==null) 
  5.                 return i; 
  6.     } else { 
  7.         for (int i = 0; i < size; i++) 
  8.            //对象通过 equals 方法，判断是否相同 
  9.             if (o.equals(elementData[i])) 
  10.                 return i; 
  11.     } 
  12.     return -1; 
  13. } 

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

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

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

三、java 8中去重操作

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

  1. public static void main(String[] args) { 
  2.     //添加信息 
  3.     List penBeanList = new ArrayList(); 
  4.     penBeanList.add(new PenBean("铅笔","black")); 
  5.     penBeanList.add(new PenBean("铅笔","white")); 
  6.     penBeanList.add(new PenBean("铅笔","black")); 
  7.     penBeanList.add(new PenBean("中性笔","white")); 
  8.     penBeanList.add(new PenBean("中性笔","white")); 
  9.  
  10.     //使用java8新特性stream进行List去重 
  11.     List newPenBeanList = penBeanList.stream().distinct().collect(Collectors.toList()); 
  12.  
  13.     //输出结果 
  14.     System.out.println("=========新数据======"); 
  15.     for (PenBean penBean : newPenBeanList) { 
  16.         System.out.println(penBean.toString()); 
  17.     } 
  18. } 

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

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

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

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

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

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

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

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

  1. public final class String 
  2. implements java.io.Serializable, Comparable, CharSequence { 
  3.   
  4.  @Override 
  5.  public boolean equals(Object anObject) { 
  6.         if (this == anObject) { 
  7.             return true; 
  8.         } 
  9.         if (anObject instanceof String) { 
  10.             String anotherString = (String)anObject; 
  11.             int n = value.length; 
  12.             if (n == anotherString.value.length) { 
  13.                 char v1[] = value; 
  14.                 char v2[] = anotherString.value; 
  15.                 int i = 0; 
  16.                 while (n-- != 0) { 
  17.                     if (v1[i] != v2[i]) 
  18.                         return false; 
  19.                     i++; 
  20.                 } 
  21.                 return true; 
  22.             } 
  23.         } 
  24.         return false; 
  25.     } 
  26.   
  27.  @Override 
  28.  public int hashCode() { 
  29.     int h = hash; 
  30.     if (h == 0 && value.length > 0) { 
  31.         char val[] = value; 
  32.  
  33.         for (int i = 0; i < value.length; i++) { 
  34.             h = 31 * h + val[i]; 
  35.         } 
  36.         hash = h; 
  37.     } 
  38.     return h; 
  39. } 
  40. } 

四、HashSet去重操作

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

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

实践代码如下!

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

  1.  
  2. public class PenBean { 
  3.      
  4.     private String type; 
  5.      
  6.     private String color; 
  7.     //... 省略 setter 和 getter 
  8.     public PenBean(String type, String color) { 
  9.         this.type = type; 
  10.         this.color = color; 
  11.     } 
  12.     @Override 
  13.     public String toString() { 
  14.         return "PenBean{" + 
  15.                 "type='" + type + '\'' + 
  16.                 ", color='" + color + '\'' + 
  17.                 '}'; 
  18.     } 
  19.   
  20.  @Override 
  21.  public boolean equals(Object o) { 
  22.       if (this == o) return true; 
  23.       if (o == null || getClass() != o.getClass()) return false; 
  24.       PenBean penBean = (PenBean) o; 
  25.       //当type、color 内容都相等的时候，才返回true 
  26.       return Objects.equals(type, penBean.type) && 
  27.           Objects.equals(color, penBean.color); 
  28.  } 
  29.   
  30.  @Override 
  31.  public int hashCode() { 
  32.     return Objects.hash(type, color); 
  33.  } 
  34.    
  35. } 

创建测试 demo，如下：

  1. public static void main(String[] args) { 
  2.     //添加信息 
  3.     List penBeanList = new ArrayList(); 
  4.     penBeanList.add(new PenBean("铅笔","black")); 
  5.     penBeanList.add(new PenBean("铅笔","white")); 
  6.     penBeanList.add(new PenBean("铅笔","black")); 
  7.     penBeanList.add(new PenBean("中性笔","white")); 
  8.     penBeanList.add(new PenBean("中性笔","white")); 
  9.  
  10.     //新数据 
  11.     List newPenBeanList = new ArrayList(); 
  12.     //set去重 
  13.     HashSet set = new HashSet<>(penBeanList); 
  14.     newPenBeanList.addAll(set); 
  15.  
  16.     //输出结果 
  17.     System.out.println("=========新数据======"); 
  18.     for (PenBean penBean : newPenBeanList) { 
  19.         System.out.println(penBean.toString()); 
  20.     } 
  21. } 

输出结果如下：

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

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

那HashSet是怎么做的的呢?

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

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

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

  1. public boolean addAll(Collection c) { 
  2.     boolean modified = false; 
  3.     for (E e : c) 
  4.         if (add(e)) 
  5.             modified = true; 
  6.     return modified; 
  7. } 

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

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

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

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

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

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

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

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

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

 

来源：Java极客技术内容投诉

免责声明：

① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的，并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据，供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。

② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

软考中级精品资料免费领

  • 历年真题答案解析
  • 备考技巧名师总结
  • 高频考点精准押题

  • 2024年上半年信息系统项目管理师第二批次真题及答案解析（完整版）

    难度     813人已做
    查看

  • 【考后总结】2024年5月26日信息系统项目管理师第2批次考情分析

    难度     354人已做
    查看

  • 【考后总结】2024年5月25日信息系统项目管理师第1批次考情分析

    难度     318人已做
    查看

  • 2024年上半年软考高项第一、二批次真题考点汇总（完整版）

    难度     435人已做
    查看

  • 2024年上半年系统架构设计师考试综合知识真题

    难度     224人已做
    查看

相关文章

发现更多好内容

猜你喜欢

AI推送时光机

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

后端开发List元素2024-12-11

java中怎么去掉List集合中重复的元素

后端开发2024-04-02

面试官：如何实现 List 集合去重？

后端开发List2024-12-02

java中如何使list集合中元素不重复

java中如何使list集合中元素不重复
后端开发2015-05-07

JAVA8 获取list集合中重复的元素和获取去重数据

后端开发2023-08-23
位置：首页-资讯-后端开发
咦！没有更多了？去看看其它编程学习网 内容吧
首页课程
资料下载问答资讯