Summary of deduplication and sorting according to the properties of objects in the list (must read)

//Do notpublic class User {
    private int id;
    private String name;
    private int age;
    public User(){}
    public User(int id, String name, int age) {
      super();
       = id;
       = name;
       = age;
    }
    public int getId() {
      return id;
    }
    public void setId(int id) {
       = id;
    }
    public String getName() {
      return name;
    }
    public void setName(String name) {
       = name;
    }
    public int getAge() {
      return age;
    }
    public void setAge(int age) {
       = age;
    }
    @Override
    public String toString() {
      return "User [, name=" + name + ", age=" + age + "]";
    }
     
  }

public class ListTest {
/**
  * There is a List<User> list that places five objects: user1, user2, user3, user4, user5
   User has three attributes: Id, name, and age
   The record of user2 is roughly like this: "100", "abc", 20;
   The record of user3 is roughly like this: "100", "def", 20;
   How can I only keep one object in user2 and user3 and merge the name in it into a new object?
   New objects such as "100", "abcdef", 20
   This is just an example. In reality, it is possible that user4 and user5 are similar to this. If there are two objects with the same id, then do it
   Merge, only one object is retained, and a common method can be used to filter out two objects with the same ID in the object collection and merge them.
   Still retained in the original list
  * @param args
  */
  // List is ordered and repeatable, set is unordered and cannot be repeated, mapkey is not allowed to be repeated, the value after the same key will overwrite the previous one  //The data stored in List is stored in the order when it is placed by default. For example, if A, B, and C are placed in sequence, then when it is obtained, it is also the order of A, B, and C.  public static void main(String[] args) {
    List&lt;User&gt; list = new ArrayList&lt;&gt;();
    (new User(1,"a",20));
    (new User(1,"a",20));
    (new User(2,"a",20));
    (new User(3,"b",20));
    (new User(1,"c",20));
    (new User(4,"d",20));
    (new User(2,"e",20));
    (new User(1,"a",20));
    /* for (User user : list) {
      (());
    } 
    ();*/
    list = mySort(list);
    for (User user : list) {
      (());
    }
       
    }
    public static List&lt;User&gt; mySort(List&lt;User&gt; list){
      HashMap&lt;Integer,User&gt; tempMap = new HashMap&lt;&gt;();
      for (User user : list) {
        int key = ();
// containsKey(Object key) This method determines whether the specified key name is included in the Map collection object.  Return true if the Map collection contains the specified key name, otherwise false// containsValue(Object value) value: the specified key-value object of the Map collection to be queryed. Return true if the specified key value is contained in the Map collection, otherwise return false        if((key)){
          User tempUser = new User(key,
                       (key).getName() + (),
                       (key).getAge());//();
//HashMap does not allow key duplication, so if there is a key duplication, the previous value will be overwritten by the subsequent value          (key, tempUser);
        }else{
          (key, user);
        }
      }
      List&lt;User&gt; tempList = new ArrayList&lt;&gt;();
      for(int key : ()){
        ((key));
      }
      return tempList;
    }

  }

//Sorting==========================================================================================================================================================================================================================================================public class Student {
  private int age; 
  private String name; 
  public int getAge() { 
    return age; 
  } 
 
  public void setAge(int age) { 
     = age; 
  } 

  public String getName() {
    return name;
  }

  public void setName(String name) {
     = name;
  }

  @Override
  public String toString() {
    return "Student [age=" + age + ", name=" + name + "]";
  } 
  
}
public class ListSort {

  public static void main(String[] args) {
     List&lt;Student&gt; list = new ArrayList&lt;Student&gt;(); 
     
      //Create 3 student objects, ages 20, 19, 21, and put them in the List in turn.      Student s1 = new Student(); 
      (20); 
      ("Ge Da");
      Student s2 = new Student(); 
      (19); 
      ("Zhang Jie");
      Student s3 = new Student(); 
      (21); 
      ("Bao Ye");
      (s1); 
      (s2); 
      (s3); 
       
      ("Before sorting:"+list); 
      
      (list, new Comparator&lt;Student&gt;(){ 
   
        /*
          * int compare(Student o1, Student o2) Returns an integer of the basic type,
          * Return negative number: o1 is less than o2,
          * Return to 0 means: o1 and o2 are equal,
          * Return positive number to indicate: o1 is greater than o2. 
          */ 
        public int compare(Student o1, Student o2) { 
         
          //Arrange ascending order according to the age of the students; < is descending order//          /*if(() &gt; ()){ 
//            return 1; 
//          } 
//          if(() == ()){ 
//            return 0; 
//          } 
//          return -1; */
// return ()-();// Ascending order// return ()-();// descending order          return ().compareTo(()) ;// Ascending order by name// return ().compareTo(());// descending order by name        } 
      });  
      ("After sorting:"+list); 
    } 

  }