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

本篇內容介紹了“java中怎么去掉List集合中重復的元素”的有關知識，在實際案例的操作過程中，不少人都會遇到這樣的困境，接下來就讓小編帶領大家學習一下如何處理這些情況吧！希望大家仔細閱讀，能夠學有所成！

 一、問題由來

在實際開發的時候，我們經常會碰到這么一個困難：一個集合容器里面有很多重復的對象，里面的對象沒有主鍵，但是根據業務的需求，實際上我們需要根據條件篩選出沒有重復的對象。

比較暴力的方法，就是根據業務需求，通過兩層循環來進行判斷，沒有重復的元素就加入到新集合中，新集合中已經有的元素就跳過。

操作例子如下，創建一個實體對象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<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()方法就是!

二、利用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()方法的原因!

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

四、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()方法進行包裝，即可得到我們想要的不包含重復元素的數據!

“java中怎么去掉List集合中重復的元素”的內容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業相關的知識可以關注億速云網站，小編將為大家輸出更多高質量的實用文章！