//去重
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);
}
}
