List去重为什么要写equals()，hashCode()方法

一，各个集合的特点：

• 　　Collection(集合):容器,用于存放对象(引用类型。基本类型需要自动装箱)   
• 　　List(列表):元素有序,元素可以重复 (有索引)。 通过元素的equals()方法判断是否重复。  
• 　　Set(集):元素无序,不可重复 (没有索引)。 遍历只能用Iterator迭代器和增强for, 不能使用普通for遍历。 
• 　　ArrayList(数组列表): 查询快,增删慢。   
• 　　LinkedList(链表): 查询慢,增删快。
• 　　HashSet(哈希表): 查询快,增删慢。 (底层其实就是Map) 。 存放的引用类型需重写hashCode()和equals()方法。 
• 　　LinkedHashSet(哈希链表): 查询慢,增删快。 有序的,存放顺序和取出顺序一致。

1.1，为什么要去重：

• 　　在我们开发中，我们所读取的数据难免会有重复数据，我们需要的则是不重复数据的引用，所以需要对数据进行去重，
• 　　而基本数据类型的去重比较好去重而引用数据类型呢，因为要判断hashCode运算是否相等，还有equals()是否相等，所以需要去重操作，
• 　　我们以一个list集合为例，在该例中，我们将User实体类中姓名和电话号码作为判断该对象重复的标识，在User的实体类中我们重写
• 　　这两个方法如下：

 1 package com.example.pojo;
 2 
 3 public class User {
 4     private String name;
 5     private String region;
 6     private Integer performance;
 7     public User(String name, String region, Integer performance) {
 8         super();
 9         this.name = name;
10         this.region = region;
11         this.performance = performance;
12     }
13     @Override
14     public String toString() {
15         return "User [name=" + name + ", region=" + region + ", performance=" + performance + "]";
16     }
17     @Override
18     public int hashCode() {
19         final int prime = 31;
20         int result = 1;
21         result = prime * result + ((name == null) ? 0 : name.hashCode());
22         result = prime * result + ((performance == null) ? 0 : performance.hashCode());
23         result = prime * result + ((region == null) ? 0 : region.hashCode());
24         return result;
25     }
26     @Override
27     public boolean equals(Object obj) {
28         if (this == obj)
29             return true;
30         if (obj == null)
31             return false;
32         if (getClass() != obj.getClass())
33             return false;
34         User other = (User) obj;
35         if (name == null) {
36             if (other.name != null)
37                 return false;
38         } else if (!name.equals(other.name))
39             return false;
40         if (performance == null) {
41             if (other.performance != null)
42                 return false;
43         } else if (!performance.equals(other.performance))
44             return false;
45         if (region == null) {
46             if (other.region != null)
47                 return false;
48         } else if (!region.equals(other.region))
49             return false;
50         return true;
51     }
52 }

• 以上实体类中，我们在equals()方法中取出该对象的name与region和performance这三个属性值去判断比较，然后在重写的hashCode()
• 方法中返回这三个属性值得equals对象地址值。

1.2，去重操作步骤：

 1 package com.example.arraylist;
 2 
 3 import java.util.ArrayList;
 4 import java.util.Iterator;
 5 import java.util.List;
 6 import com.example.pojo.User;
 7 
 8 /**
 9  * @author Administrator
10  *    思路:
11  *        1.先对其文本文本进行添加,添加到List中
12  *        2.把List用迭代器进行迭代
13  *        3.创建一个新的集合,用来存储不重复的元素
14  *        4.用while(it.hasNext())有多少元素就循环多少次    
15  *        4.判断新的集合是否有旧的元素如果没有则进行添加
16  */
17 public class ListUserRepeat {
18     public static void main(String[] args) {
19         String string="张三,河北,90\n"+
20                 "张三,河南,92\n"+
21                 "李四,湖北,80\n"+
22                 "王五,山西,88\n"+
23                 "张三,河北,90\n"+
24                 "李四,湖北,80\n"+
25                 "马六,山东,77\n";
26         List list = new ArrayList<>();
27         String[] split = string.split("\n");
28         for(String spl : split) {
29             String[] split2 = spl.split(",");
30             list.add(new User(split2[0], split2[1],Integer.parseInt(split2[2])));
31         }
32         Iterator it = list.iterator();
33         List listOne = new ArrayList<>();
34         while(it.hasNext()) {
35             Object object = it.next();
36             if(!listOne.contains(object)) {
37                 listOne.add((User) object);
38             }
39         }
40         for (User user : listOne) {
41             System.out.println(user);
42         }
43     }
44 }

运行这段代码之后，就会很明显的发现,list中重复的用户名，地区，都相同的对象就被会认为是重复的元素而删除掉，很明显运行结果已经达到我们的目的。

二，说一下为什么需要重写equals()方法和hashChode方法()：

• 一般情况下我们重写equals()方法的时候还要重写hashChode()方法，但是我们用的是list所以不用重写hashCode，大家不妨
• 可以试试上面的例子，在实体类将重写的equals()方法注释掉，再运行程序，这时就会发现运行结果并不是我们刚刚得到的结果，（图中 我用的是list集合，
• 不是set集合，list集合只需要重写equals()方法就行，而set集合则equals()和hashCode()方法都需要重写）

2.1,String类中的equals()方法的源码如下:

 1     public boolean equals(Object anObject) {
 2         if (this == anObject) {
 3             return true;
 4         }
 5         if (anObject instanceof String) {
 6             String anotherString = (String)anObject;
 7             int n = value.length;
 8             if (n == anotherString.value.length) {
 9                 char v1[] = value;
10                 char v2[] = anotherString.value;
11                 int i = 0;
12                 while (n-- != 0) {
13                     if (v1[i] != v2[i])
14                         return false;
15                     i++;
16                 }
17                 return true;
18             }
19         }
20         return false;
21     }

通过观察equals()方法的源码我们可以看出，该方法去比较两个对象时，首先先去判断两个对象是否具有相同的地址，如果是同一个对象的引用，则直接放回true；如果地址不一样，则证明不是引用同一个对象，接下来就是挨个去比较两个字符串对象的内容是否一致，完全相等返回true，否则false。

2.2，String类中hashCode()方法的源码如下：

 1     public int hashCode() {
 2         int h = hash;
 3         if (h == 0 && value.length > 0) {
 4             char val[] = value;
 5 
 6             for (int i = 0; i < value.length; i++) {
 7                 h = 31 * h + val[i];
 8             }
 9             hash = h;
10         }
11         return h;
12     }

以上是String类中重写的hashCode()方法，在Object类中的hashCode()方法是返回对象的32位JVM内存地址，也就是说如果我们不去重写该方法，将会返回该对象的32位JVM内存地址，以上我们测试的例子中，当注释掉重写的hashCode()方法时，这时默认返回对象的32JVM中的地址，两个不同的对象地址显然是不同的，我们在比较时，虽然通过重写的equals()方法比较出来name和phoneNumber值是相同的，但是默认的hashCode()方法返回的值他们并不是同一个对象，所以我们通常要将hashCode()方法与equals()方法一起重写，以维护hashCode方法的常规协定，该协定声明相等对象必须具有相等的哈希码。

总结：

　　用白话说，通过hashCode判断对象是否放在同一个桶里，先确定他们在一个桶里面，然后再通过equals方法去判断这个桶里的对象是不是相同的。

转载于:https://www.cnblogs.com/joeyJss/p/10172147.html