Java List实体类去重

java

今天写了一段代码判断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

回到顶部