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

public class ListTest {
/**
 *   有一個List<User> list 放了五個對象：user1、user2、user3、user4、user5
  User有三個屬性Id、name、age
  其中user2的記錄大概是這樣：“100”,"abc",20;
  user3的記錄大概是這樣：“100”，“def”,20;
  請問怎么才能只保留user2和user3中的一個對象，并將其中的name合并到新對象中，
  新對象如“100”，“abcdef”，20
  這只是舉個例子，實際中有可能user4和user5與此類似，如果有id相同的兩個對象，則對其進行
  合并，只保留一個對象，求一個通用的方法，能篩選出對象集合中某些相同ID的兩個對象，將其合并
  仍保留在原list中
 * @param args
 */
  //list有序可重復、set無序不可重復、mapkey不允許重復，key相同的后面的value會把前面的覆蓋掉
  //List存放的數據，默認是按照放入時的順序存放的，比如依次放入A、B、C，則取得時候，則也是A、B、C的順序
  public static void main(String[] args) {
    List<User> list = new ArrayList<>();
    list.add(new User(1,"a",20));
    list.add(new User(1,"a",20));
    list.add(new User(2,"a",20));
    list.add(new User(3,"b",20));
    list.add(new User(1,"c",20));
    list.add(new User(4,"d",20));
    list.add(new User(2,"e",20));
    list.add(new User(1,"a",20));
    /* for (User user : list) {
      System.out.println(user.toString());
    } 
    System.out.println();*/
    list = mySort(list);
    for (User user : list) {
      System.out.println(user.toString());
    }
       
    }
    public static List<User> mySort(List<User> list){
      HashMap<Integer,User> tempMap = new HashMap<>();
      for (User user : list) {
        int key = user.getId();
// containsKey(Object key) 該方法判斷Map集合對象中是否包含指定的鍵名。如果Map集合中包含指定的鍵名，則返回true，否則返回false
// containsValue(Object value)  value：要查詢的Map集合的指定鍵值對象.如果Map集合中包含指定的鍵值，則返回true，否則返回false
        if(tempMap.containsKey(key)){
          User tempUser = new User(key,
                       tempMap.get(key).getName() + user.getName(),
                       tempMap.get(key).getAge());//user.getAge();
//HashMap是不允許key重復的，所以如果有key重復的話，那么前面的value會被后面的value覆蓋          
          tempMap.put(key, tempUser);
        }else{
          tempMap.put(key, user);
        }
      }
      List<User> tempList = new ArrayList<>();
      for(int key : tempMap.keySet()){
        tempList.add(tempMap.get(key));
      }
      return tempList;
    }

  }

//排序=============================================
public class Student {
  private int age; 
  private String name; 
  public int getAge() { 
    return age; 
  } 
 
  public void setAge(int age) { 
    this.age = age; 
  } 

  public String getName() {
    return name;
  }

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

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

  public static void main(String[] args) {
     List<Student> list = new ArrayList<Student>(); 
     
      //創建3個學生對象，年齡分別是20、19、21，并將他們依次放入List中 
      Student s1 = new Student(); 
      s1.setAge(20); 
      s1.setName("葛大");
      Student s2 = new Student(); 
      s2.setAge(19); 
      s2.setName("張杰");
      Student s3 = new Student(); 
      s3.setAge(21); 
      s3.setName("寶爺");
      list.add(s1); 
      list.add(s2); 
      list.add(s3); 
       
      System.out.println("排序前："+list); 
      
      Collections.sort(list, new Comparator<Student>(){ 
   
        /* 
         * int compare(Student o1, Student o2) 返回一個基本類型的整型， 
         * 返回負數表示：o1 小于o2， 
         * 返回0 表示：o1和o2相等， 
         * 返回正數表示：o1大于o2。 
         */ 
        public int compare(Student o1, Student o2) { 
         
          //按照學生的年齡進行升序排列 ;<是降序
//          /*if(o1.getAge() > o2.getAge()){ 
//            return 1; 
//          } 
//          if(o1.getAge() == o2.getAge()){ 
//            return 0; 
//          } 
//          return -1; */
//          return o1.getAge()-o2.getAge();//升序
//          return o2.getAge()-o1.getAge();//降序 
          return o1.getName().compareTo(o2.getName()) ;// 按照姓名升序
//          return o2.getName().compareTo(o1.getName()) ;// 按照姓名降序
        } 
      });  
      System.out.println("排序后："+list); 
    } 

  }