List去重為什么要寫equals()，hashCode()方法

一，各個集合的特點：

• 　　Collection(集合):容器,用於存放對象(引用類型。基本類型需要自動裝箱)   
• 　　List(列表):元素有序,元素可以重復 (有索引)。 通過元素的equals()方法判斷是否重復。  
• 　　Set(集):元素無序,不可重復 (沒有索引)。 遍歷只能用Iterator迭代器和增強for, 不能使用普通for遍歷。 
• 　　ArrayList(數組列表): 查詢快,增刪慢。   
• 　　LinkedList(鏈表): 查詢慢,增刪快。
• 　　HashSet(哈希表): 查詢快,增刪慢。 (底層其實就是Map) 。 存放的引用類型需重寫hashCode()和equals()方法。 
• 　　LinkedHashSet(哈希鏈表): 查詢慢,增刪快。 有序的,存放順序和取出順序一致。

1.1，為什么要去重：

• 　　在我們開發中，我們所讀取的數據難免會有重復數據，我們需要的則是不重復數據的引用，所以需要對數據進行去重，
• 　　而基本數據類型的去重比較好去重而引用數據類型呢，因為要判斷hashCode運算是否相等，還有equals()是否相等，所以需要去重操作，
• 　　我們以一個list集合為例，在該例中，我們將User實體類中姓名和電話號碼作為判斷該對象重復的標識，在User的實體類中我們重寫
• 　　這兩個方法如下：

package com.example.pojo;

public class User {
    private String name;
    private String region;
    private Integer performance;
    public User(String name, String region, Integer performance) {
        super();
        this.name = name;
        this.region = region;
        this.performance = performance;
    }
    @Override
    public String toString() {
        return "User [name=" + name + ", region=" + region + ", performance=" + performance + "]";
    }
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        result = prime * result + ((performance == null) ? 0 : performance.hashCode());
        result = prime * result + ((region == null) ? 0 : region.hashCode());
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        User other = (User) obj;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        if (performance == null) {
            if (other.performance != null)
                return false;
        } else if (!performance.equals(other.performance))
            return false;
        if (region == null) {
            if (other.region != null)
                return false;
        } else if (!region.equals(other.region))
            return false;
        return true;
    }
}

• 以上實體類中，我們在equals()方法中取出該對象的name與region和performance這三個屬性值去判斷比較，然后在重寫的hashCode()
• 方法中返回這三個屬性值得equals對象地址值。

1.2，去重操作步驟：

package com.example.arraylist;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import com.example.pojo.User;

/**
 * @author Administrator
 *    思路:
 *        1.先對其文本文本進行添加,添加到List<User>中
 *        2.把List<User>用迭代器進行迭代
 *        3.創建一個新的集合,用來存儲不重復的元素
 *        4.用while(it.hasNext())有多少元素就循環多少次    
 *        4.判斷新的集合是否有舊的元素如果沒有則進行添加
 */
public class ListUserRepeat {
    public static void main(String[] args) {
        String string="張三,河北,90\n"+
                "張三,河南,92\n"+
                "李四,湖北,80\n"+
                "王五,山西,88\n"+
                "張三,河北,90\n"+
                "李四,湖北,80\n"+
                "馬六,山東,77\n";
        List<User> list = new ArrayList<>();
        String[] split = string.split("\n");
        for(String spl : split) {
            String[] split2 = spl.split(",");
            list.add(new User(split2[0], split2[1],Integer.parseInt(split2[2])));
        }
        Iterator<User> it = list.iterator();
        List<User> listOne = new ArrayList<>();
        while(it.hasNext()) {
            Object object = it.next();
            if(!listOne.contains(object)) {
                listOne.add((User) object);
            }
        }
        for (User user : listOne) {
            System.out.println(user);
        }
    }
}

運行這段代碼之后，就會很明顯的發現,list中重復的用戶名，地區，都相同的對象就被會認為是重復的元素而刪除掉，很明顯運行結果已經達到我們的目的。

二，說一下為什么需要重寫equals()方法和hashChode方法()：

• 一般情況下我們重寫equals()方法的時候還要重寫hashChode()方法，但是我們用的是list所以不用重寫hashCode，大家不妨
• 可以試試上面的例子，在實體類將重寫的equals()方法注釋掉，再運行程序，這時就會發現運行結果並不是我們剛剛得到的結果，（圖中 我用的是list集合，
• 不是set集合，list集合只需要重寫equals()方法就行，而set集合則equals()和hashCode()方法都需要重寫）

2.1,String類中的equals()方法的源碼如下:

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

通過觀察equals()方法的源碼我們可以看出，該方法去比較兩個對象時，首先先去判斷兩個對象是否具有相同的地址，如果是同一個對象的引用，則直接放回true；如果地址不一樣，則證明不是引用同一個對象，接下來就是挨個去比較兩個字符串對象的內容是否一致，完全相等返回true，否則false。

2.2，String類中hashCode()方法的源碼如下：

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

以上是String類中重寫的hashCode()方法，在Object類中的hashCode()方法是返回對象的32位JVM內存地址，也就是說如果我們不去重寫該方法，將會返回該對象的32位JVM內存地址，以上我們測試的例子中，當注釋掉重寫的hashCode()方法時，這時默認返回對象的32JVM中的地址，兩個不同的對象地址顯然是不同的，我們在比較時，雖然通過重寫的equals()方法比較出來name和phoneNumber值是相同的，但是默認的hashCode()方法返回的值他們並不是同一個對象，所以我們通常要將hashCode()方法與equals()方法一起重寫，以維護hashCode方法的常規協定，該協定聲明相等對象必須具有相等的哈希碼。

總結：

　　用白話說，通過hashCode判斷對象是否放在同一個桶里，先確定他們在一個桶里面，然后再通過equals方法去判斷這個桶里的對象是不是相同的。