App下載

List 集合去重的 3 種方法

猿友 2020-08-17 14:37:41 瀏覽數(shù) (8085)
反饋

問題由來

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

比較暴力的方法，就是根據(jù)業(yè)務需求，通過兩層循環(huán)來進行判斷，沒有重復的元素就加入到新集合中，新集合中已經(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<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"));


    //新數(shù)據(jù)
    List<PenBean> newPenBeanList = new ArrayList<PenBean>();
    //傳統(tǒng)重復判斷
    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);
            }
        }
    }

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

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

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

（推薦教程：Java教程）

1、利用list中contains方法去重

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

我們先在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;
   //當type、color 內(nèi)容都相等的時候，才返回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"));


    //新數(shù)據(jù)
    List<PenBean> newPenBeanList = new ArrayList<PenBean>();
    //使用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ù)是一樣的，并不能達到我們想要除去重復元素的目的

那么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，如果有就返回下標；如果傳入的對象不是null，通過對象的equals()方法，for 循環(huán)判斷是否有相同的元素，如果有就返回下標！

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

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

2、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());


    //輸出結(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)集合元素的去重操作！

那為什么當我們使用String類型的對象作為集合元素時，沒有重寫呢？

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

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

（推薦微課：Java微課）

3、HashSet去重操作

在上面的分享中，我們介紹了 List 的集合去重操作！其中網(wǎng)友還提到了HashSet可以實現(xiàn)元素的去重！

的確，HashSet集合天然支持元素不重復！

實踐代碼如下！

還是先創(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;
      //當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<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"));


    //新數(shù)據(jù)
    List<PenBean> newPenBeanList = new ArrayList<PenBean>();
    //set去重
    HashSet<PenBean> 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'}

很明細，返回的新集合沒有重復元素！

那HashSet是怎么做的的呢？

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

public HashSet(Collection<? extends E> 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<? extends E> 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<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時，就可以達到元素去重的目的！

（推薦內(nèi)容：Java面試基礎(chǔ)題）

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

文章來源于：mp.weixin.qq.com/s/LBjfarlK5Qv-A85Hey0btA
作者：鴨血粉絲

以上就是關(guān)于List集合去重的 3 種方法的相關(guān)介紹，希望對大家有所幫助。

Java

0 人點贊