Java List实体类去重

• Z时代
• 2024-01-10
• 分类：综合

今天写了一段代码判断list中是否包含某个实体openSubjectDTO,不包含就添加进去,发现不好使

if(!subjectList.contains(openSubjectDTO)){
subjectList.add(openSubjectDTO);
}

后来发现是openSubjectDTO类中缺少两个方法如下:

List 去除重复Object对象：

    对象重复是指对象里面的变量的值都相等，并不定是地址。list集合存储的类型是基础类型还比较好办，直接把list集合转换成set集合就会自动去除。

   当set集合存储的是对象类型时，需要在对象的实体类里面重写public boolean equals(Object obj) {} 和 public int hashCode() {} 两个方法。

List特点：元素有放入顺序，元素可重复 

Map特点：元素按键值对存储，无放入顺序 

Set特点：元素无放入顺序，元素不可重复（注意：元素虽然无放入顺序，但是元素在set中的位置是有该元素的HashCode决定的，其位置其实是固定的） 

新建一个实体类

[java] view plain copy

1. public class User {  
2.     private String id;  

3.     private String name;  

4.     private String age;  

5.     private String address;  

6.   
7.     public String getId() {  

8.         return id;  

9.     }  
10.   
11.     public void setId(String id) {  

12.         this.id = id;  

13.     }  
14.   
15.     public String getName() {  

16.         return name;  

17.     }  
18.   
19.     public void setName(String name) {  

20.         this.name = name;  

21.     }  
22.   
23.     public String getAge() {  

24.         return age;  

25.     }  
26.   
27.     public void setAge(String age) {  

28.         this.age = age;  

29.     }  
30.   
31.     public String getAddress() {  

32.         return address;  

33.     }  
34.   
35.     public void setAddress(String address) {  

36.         this.address = address;  

37.     }  
38.   
39.     @Override  

40.     public int hashCode() {  

41.         final int prime = 31;  

42.         int result = 1;  

43.         result = prime * result + ((id == null) ? 0 : id.hashCode());  

44.         result = prime * result + ((name == null) ? 0 : name.hashCode());  

45.         result = prime * result + ((age == null) ? 0 : age.hashCode());  

46.         result = prime * result + ((address == null) ? 0 : address.hashCode());  

47.         return result;  

48.     }  
49.   
50.     @Override  

51.     public boolean equals(Object obj) {  

52.         if (this == obj) {  

53.             return true;  

54.         }  
55.         if (obj == null) {  

56.             return false;  

57.         }  
58.         if (getClass() != obj.getClass()) {  

59.             return false;  

60.         }  
61.         User other = (User) obj;  
62.         if (id == null) {  

63.             if (other.id != null) {  

64.                 return false;  

65.             }  
66.         } else if (!id.equals(other.id)) {  

67.             return false;  

68.         }  
69.         if (name == null) {  

70.             if (other.name != null) {  

71.                 return false;  

72.             }  
73.         } else if (!name.equals(other.name)) {  

74.             return false;  

75.         }  
76.         if (age == null) {  

77.             if (other.age != null) {  

78.                 return false;  

79.             }  
80.         } else if (!age.equals(other.age)) {  

81.             return false;  

82.         }  
83.         if (address == null) {  

84.             if (other.address != null) {  

85.                 return false;  

86.             }  
87.         } else if (!address.equals(other.address)) {  

88.             return false;  

89.         }  
90.         return true;  

91.     }  
92. }  

调用即可

[java] view plain copy

1. private static List<User> removeListDuplicateObject(List<User> list) {   
2.     System.out.println(Arrays.toString(list.toArray()));   
3.     Set<User> set = new HashSet<User>();   

4.     set.addAll(list);   
5.     System.out.println(Arrays.toString(set.toArray()));  
6.     List<User> listnewList = new ArrayList<User>(set);  

7.     return listnewList;  

8.     }   

以上是 Java List实体类去重 的全部内容， 来源链接： utcz.com/z/393961.html