您現在的位置是:首頁 > 垂釣

面試官提問:如何去掉list集合中重複的元素?

  • 由 佳雲大腦 發表于 垂釣
  • 2022-11-09
簡介}}測試 demo,如下:public static void main(String[] args) {    新增資訊,PenBean中沒有主鍵    List penBeanList = new ArrayList()

集合中能有相同元素嗎

面試官提問:如何去掉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 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()方法,內容如下:

@Overridepublic 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()方法,程式碼如下:

@Overridepublic 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 Stringimplements 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<? 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 map = new HashMap();map。put(e,new Object);//e表示要插入的元素

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

我們知道HashMap,是透過equals()和hashCode()來判斷插入的key是否為同一個key

,因此,當我們對PenBean物件進行重寫equals()和hashCode()時,保證判斷是同一個key時,就可以達到元素去重的目的!

最後,

對已經去重的集合HashSet,再透過ArrayList中的addAll()方法進行包裝,即可得到我們想要的不包含重複元素的資料

五、參考

JDK1。8-原始碼分析

Top