List去重问题引出来的hashCode和equals方法

一、List 里面是基本类型的去重问题

 1 import java.util.ArrayList;
 2 import java.util.HashSet;
 3 import java.util.List;
 4 import java.util.Set;
 5 
 6 /**
 7  * 
 8  * @author Jenson 2018年10月31日下午2:26:02
 9  */
10 public class Demo {
11 
12     public static void main(String[] args) {
13         List list = new ArrayList();
14         list.add(11);
15         list.add(12);
16         list.add(13);
17         list.add(14);
18         list.add(15);
19         list.add(11);
20         System.out.println(list);
21         Set set = new HashSet();
22         List newList = new ArrayList();
23         set.addAll(list);
24         newList.addAll(set);
25         System.out.println(newList);
26     }
27 }

这样子可以看到已经去重成功了。

在面试中被问到 List 去重的时候，回答出 List 和Set互转并不会是满意的答案，当 List 集合中存在对象的时候，就要使用下面的方式去去重。

二、List 集合里面存在引用类型(对象)

2.1

我们定义一个People类，然后重写 equals 和 hashCode 方法

 1 public class People {
 2     private String name;
 3     private String phoneNumber;
 4 
 5     public String getName() {
 6         return name;
 7     }
 8 
 9     public void setName(String name) {
10         this.name = name;
11     }
12 
13     public String getPhoneNumber() {
14         return phoneNumber;
15     }
16 
17     public void setPhoneNumber(String phoneNumber) {
18         this.phoneNumber = phoneNumber;
19     }
20 
21     public People(String name, String phoneNumber) {
22         super();
23         this.name = name;
24         this.phoneNumber = phoneNumber;
25     }
26 
27     @Override
28     public String toString() {
29         return "People [name=" + name + ", phoneNumber=" + phoneNumber + "]";
30     }
31 
32     @Override
33     public int hashCode() {
34 
35         // 判断这个对象的属性的hashCode
36 
37         String str = name + phoneNumber;
38         return str.hashCode();
39     }
40 
41     @Override
42     public boolean equals(Object obj) {
43         People p = (People) obj;
44 
45         // 分别判断这个对象的属性是否物理相等
46 
47         return name.equals(p.name) && phoneNumber.equals(p.phoneNumber);
48     }
49 
50 }

如果继续使用一中的方法去重，可以看到是没有去重的。

 1 public static void main(String[] args) {
 2     List<People> listPeople = new ArrayList<People>();
 3     listPeople.add(new People("张三", "11111"));
 4     listPeople.add(new People("张三",  "22222"));
 5     listPeople.add(new People("李四",  "33333"));
 6     listPeople.add(new People("张三",  "22222"));
 7  
 8     Set<People> setData = new HashSet<People>();
 9     setData.addAll(listPeople);
10     System.out.println("list：" + listPeople.toString());
11     System.out.println("set：" + setData.toString());
12  
13 }

可以看到并没有去掉最后一个对象。

这个时候我们必须在 People 类中重写 equals 和 hashCode 方法

 1 public class People {
 2     private String name;
 3     private String phoneNumber;
 4 
 5     public String getName() {
 6         return name;
 7     }
 8 
 9     public void setName(String name) {
10         this.name = name;
11     }
12 
13     public String getPhoneNumber() {
14         return phoneNumber;
15     }
16 
17     public void setPhoneNumber(String phoneNumber) {
18         this.phoneNumber = phoneNumber;
19     }
20 
21     public People(String name, String phoneNumber) {
22         super();
23         this.name = name;
24         this.phoneNumber = phoneNumber;
25     }
26 
27     @Override
28     public String toString() {
29         return "People [name=" + name + ", phoneNumber=" + phoneNumber + "]";
30     }
31 
32     @Override
33     public int hashCode() {
34 
35         // 判断这个对象的属性的hashCode
36 
37         String str = name + phoneNumber;
38         return str.hashCode();
39     }
40 
41     @Override
42     public boolean equals(Object obj) {
43         People p = (People) obj;
44 
45         // 分别判断这个对象的属性是否物理相等
46 
47         return name.equals(p.name) && phoneNumber.equals(p.phoneNumber);
48     }
49 
50 }

重写之后再运行测试方法，输出结果如下：

可以看到最后一个元素已经去除成功。