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

本篇内容介绍了“java中怎么去掉List集合中重复的元素”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！

创新互联主营肇东网站建设的网络公司,主营网站建设方案,app软件开发公司,肇东h5微信小程序开发搭建,肇东网站营销推广欢迎肇东等地区企业咨询

 一、问题由来

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

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

操作例子如下，创建一个实体对象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 + '\'' +                 '}';     } }

测试 demo，如下：

public static void main(String[] args) {     //添加信息，PenBean中没有主键     List penBeanList = new ArrayList();     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 newPenBeanList = new ArrayList();     //传统重复判断     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()方法就是!

二、利用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 penBeanList = new ArrayList();     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 newPenBeanList = new ArrayList();     //使用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()方法的原因!

三、java 8中去重操作

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

public static void main(String[] args) {     //添加信息     List penBeanList = new ArrayList();     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 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, 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; } }

四、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 penBeanList = new ArrayList();     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 newPenBeanList = new ArrayList();     //set去重     HashSet 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 c) {     map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));     addAll(c); }

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

public boolean addAll(Collection 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 map = new HashMap(); map.put(e,new Object);//e表示要插入的元素

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

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

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

“java中怎么去掉List集合中重复的元素”的内容就介绍到这里了，感谢大家的阅读。如果想了解更多行业相关的知识可以关注创新互联网站，小编将为大家输出更多高质量的实用文章！

当前文章：java中怎么去掉List集合中重复的元素
文章来源：http://mswzjz.cn/article/jsophd.html