一、問題由來
在實際開發的時候，我們經常會碰到這么一個困難：一個集合容器里面有很多重復的物件，里面的物件沒有主鍵，但是根據業務的需求，實際上我們需要根據條件篩選出沒有重復的物件，
比較暴力的方法，就是根據業務需求，通過兩層回圈來進行判斷，沒有重復的元素就加入到新集合中，新集合中已經有的元素就跳過，
操作例子如下，創建一個物體物件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()方法進行包裝，即可得到我們想要的不包含重復元素的資料！
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/79285.html
標籤：Java
上一篇：求最大公約數和最小公倍數