日本综合一区二区|亚洲中文天堂综合|日韩欧美自拍一区|男女精品天堂一区|欧美自拍第6页亚洲成人精品一区|亚洲黄色天堂一区二区成人|超碰91偷拍第一页|日韩av夜夜嗨中文字幕|久久蜜综合视频官网|精美人妻一区二区三区

本文轉(zhuǎn)載自微信公眾號「Java極客技術(shù)」，作者鴨血粉絲。轉(zhuǎn)載本文請聯(lián)系Java極客技術(shù)公眾號。

 一、問題由來

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

比較暴力的方法，就是根據(jù)業(yè)務(wù)需求，通過兩層循環(huán)來進(jìn)行判斷，沒有重復(fù)的元素就加入到新集合中，新集合中已經(jīng)有的元素就跳過。

操作例子如下，創(chuàng)建一個實體對象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")); 
  
  
  
  
 
  
  
  
  
    //新數(shù)據(jù) 
  
  
  
  
    List newPenBeanList = new ArrayList(); 
  
  
  
  
    //傳統(tǒng)重復(fù)判斷 
  
  
  
  
    for (PenBean penBean : penBeanList) { 
  
  
  
  
        if(newPenBeanList.isEmpty()){ 
  
  
  
  
            newPenBeanList.add(penBean); 
  
  
  
  
        }else{ 
  
  
  
  
            boolean isSame = false; 
  
  
  
  
            for (PenBean newPenBean : newPenBeanList) { 
  
  
  
  
                //依靠type、color來判斷，是否有重復(fù)元素 
  
  
  
  
                //如果新集合包含元素，直接跳過 
  
  
  
  
                if(penBean.getType().equals(newPenBean.getType()) && penBean.getColor().equals(newPenBean.getColor())){ 
  
  
  
  
                    isSame = true; 
  
  
  
  
                    break; 
  
  
  
  
                } 
  
  
  
  
            } 
  
  
  
  
            if(!isSame){ 
  
  
  
  
                newPenBeanList.add(penBean); 
  
  
  
  
            } 
  
  
  
  
        } 
  
  
  
  
    } 
  
  
  
  
 
  
  
  
  
    //輸出結(jié)果 
  
  
  
  
    System.out.println("=========新數(shù)據(jù)======"); 
  
  
  
  
    for (PenBean penBean : newPenBeanList) { 
  
  
  
  
        System.out.println(penBean.toString()); 
  
  
  
  
    } 
  
  
  
  
} 
 
 
 
 

輸出結(jié)果：

 
 
 
 

  
  
  
  
=========新數(shù)據(jù)====== 
  
  
  
  
PenBean{type='鉛筆', color='black'} 
  
  
  
  
PenBean{type='鉛筆', color='white'} 
  
  
  
  
PenBean{type='中性筆', color='white'} 
 
 
 
 

一般處理數(shù)組類型的對象時，可以通過這種方法來對數(shù)組元素進(jìn)行去重操作，以篩選出沒有包含重復(fù)元素的數(shù)組。

那有沒有更加簡潔的寫法呢?

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

二、利用list中contains方法去重

在使用contains()之前，必須要對PenBean類重寫equals()方法，為什么要這么做?等會會詳細(xì)解釋!

我們先在PenBean類中重寫equals()方法，內(nèi)容如下：

 
 
 
 

  
  
  
  
@Override 
  
  
  
  
public boolean equals(Object o) { 
  
  
  
  
    if (this == o) return true; 
  
  
  
  
    if (o == null || getClass() != o.getClass()) return false; 
  
  
  
  
    PenBean penBean = (PenBean) o; 
  
  
  
  
   //當(dāng)type、color 內(nèi)容都相等的時候，才返回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")); 
  
  
  
  
 
  
  
  
  
    //新數(shù)據(jù) 
  
  
  
  
    List newPenBeanList = new ArrayList(); 
  
  
  
  
    //使用contain判斷，是否有相同的元素 
  
  
  
  
    for (PenBean penBean : penBeanList) { 
  
  
  
  
        if(!newPenBeanList.contains(penBean)){ 
  
  
  
  
            newPenBeanList.add(penBean); 
  
  
  
  
        } 
  
  
  
  
    } 
  
  
  
  
 
  
  
  
  
    //輸出結(jié)果 
  
  
  
  
    System.out.println("=========新數(shù)據(jù)======"); 
  
  
  
  
    for (PenBean penBean : newPenBeanList) { 
  
  
  
  
        System.out.println(penBean.toString()); 
  
  
  
  
    } 
  
  
  
  
} 
 
 
 
 

輸出結(jié)果如下：

 
 
 
 

  
  
  
  
=========新數(shù)據(jù)====== 
  
  
  
  
PenBean{type='鉛筆', color='black'} 
  
  
  
  
PenBean{type='鉛筆', color='white'} 
  
  
  
  
PenBean{type='中性筆', color='white'} 
 
 
 
 

如果PenBean對象不重寫equals()，contains()方法的都是false!新數(shù)據(jù)與源數(shù)據(jù)是一樣的，并不能達(dá)到我們想要除去重復(fù)元素的目的

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

我們打開ArrayList中contains()方法，源碼如下：

 
 
 
 

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

找到indexOf(o)方法，繼續(xù)往下看，源碼如下：

 
 
 
 

  
  
  
  
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循環(huán)判斷數(shù)組中的元素是否有null，如果有就返回下標(biāo);如果傳入的對象不是null，通過對象的equals()方法，for循環(huán)判斷是否有相同的元素，如果有就返回下標(biāo)!

如果是數(shù)組返回的下標(biāo)，肯定是大于0，否則返回-1!

這就是為什么在List中使用contains()方法，對象需要重寫equals()方法的原因!

三、java 8中去重操作

當(dāng)然，有些朋友可能會想到 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進(jìn)行List去重 
  
  
  
  
    List newPenBeanList = penBeanList.stream().distinct().collect(Collectors.toList()); 
  
  
  
  
 
  
  
  
  
    //輸出結(jié)果 
  
  
  
  
    System.out.println("=========新數(shù)據(jù)======"); 
  
  
  
  
    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，結(jié)果如下：

 
 
 
 

  
  
  
  
=========新數(shù)據(jù)====== 
  
  
  
  
PenBean{type='鉛筆', color='black'} 
  
  
  
  
PenBean{type='鉛筆', color='white'} 
  
  
  
  
PenBean{type='中性筆', color='white'} 
 
 
 
 

即可實現(xiàn)集合元素的去重操作!

那為什么當(dāng)我們使用String類型的對象作為集合元素時，沒有重寫呢?

因為 java 中String原生類，已經(jīng)重寫好了，源碼如下：

 
 
 
 

  
  
  
  
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 的集合去重操作!其中網(wǎng)友還提到了HashSet可以實現(xiàn)元素的去重!

的確，HashSet集合天然支持元素不重復(fù)!

實踐代碼如下!

還是先創(chuàng)建一個對象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; 
  
  
  
  
      //當(dāng)type、color 內(nèi)容都相等的時候，才返回true 
  
  
  
  
      return Objects.equals(type, penBean.type) && 
  
  
  
  
          Objects.equals(color, penBean.color); 
  
  
  
  
 } 
  
  
  
  
  
  
  
  
  
 @Override 
  
  
  
  
 public int hashCode() { 
  
  
  
  
    return Objects.hash(type, color); 
  
  
  
  
 } 
  
  
  
  
   
  
  
  
  
} 
 
 
 
 

創(chuàng)建測試 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")); 
  
  
  
  
 
  
  
  
  
    //新數(shù)據(jù) 
  
  
  
  
    List newPenBeanList = new ArrayList(); 
  
  
  
  
    //set去重 
  
  
  
  
    HashSet set = new HashSet<>(penBeanList); 
  
  
  
  
    newPenBeanList.addAll(set); 
  
  
  
  
 
  
  
  
  
    //輸出結(jié)果 
  
  
  
  
    System.out.println("=========新數(shù)據(jù)======"); 
  
  
  
  
    for (PenBean penBean : newPenBeanList) { 
  
  
  
  
        System.out.println(penBean.toString()); 
  
  
  
  
    } 
  
  
  
  
} 
 
 
 
 

輸出結(jié)果如下：

 
 
 
 

  
  
  
  
=========新數(shù)據(jù)====== 
  
  
  
  
PenBean{type='鉛筆', color='white'} 
  
  
  
  
PenBean{type='鉛筆', color='black'} 
  
  
  
  
PenBean{type='中性筆', color='white'} 
 
 
 
 

很明細(xì)，返回的新集合沒有重復(fù)元素!

那HashSet是怎么做的的呢?

打開HashSet的源碼，查看我們傳入的構(gòu)造方法如下：

 
 
 
 

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

很顯然，首先創(chuàng)建了一個HashMap對象，然后調(diào)用addAll()方法，繼續(xù)往下看這個方法!

 
 
 
 

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

首先遍歷List中的元素，然后調(diào)用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，因此，當(dāng)我們對PenBean對象進(jìn)行重寫equals()和hashCode()時，保證判斷是同一個key時，就可以達(dá)到元素去重的目的!

最后，對已經(jīng)去重的集合HashSet，再通過ArrayList中的addAll()方法進(jìn)行包裝，即可得到我們想要的不包含重復(fù)元素的數(shù)據(jù)!

本文題目：面試官提問:如何去掉List集合中重復(fù)的元素?
標(biāo)題來源：http://www.dlmjj.cn/article/cddhpes.html