对象去重、排序，对象拷贝

package com.lkun.springbootdemo.entity;

import lombok.Data;

import java.io.Serializable;
import java.util.Date;

/**
 * @ClassName UserEntity
 * @Description 集合排序去重、对象拷贝
 * @Author liangkun
 **/
@Data
public class UserEntity implements Cloneable,Serializable {
    private Long id;
    private String name;
    private Integer age;
    private Date createTime;
    private Boolean isChina;

    /**
     * 集合去重，要实现hashCode和equals方法
     * 有些令人疑惑的是，比较是equals方法，为什么还要实现hashCode方法呢
     * 其实底层实现，集合去重应该是先通过比较hashCode，如果相同，再去通过equals方法比较对象是否相同
     */
    @Override
    public int hashCode() {
        //hashCode散列值，尽量弄的不重样
        //int result = this.getId().intValue();
        int result = age;
        result = 31 * result + (name != null ? name.hashCode() : 0);
        return result;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof UserEntity)) return false;

        UserEntity user = (UserEntity) o;
        //if (this.getId() != user.getId()) return false;
        if(this.age != user.getAge()) return false;
        if(this.isChina != user.getIsChina()) return false;
        return this.name != null ? this.name.equals(user.getName()) : user.getName() == null;
    }

    /**
     * 在浅克隆中，如果原型对象的成员变量是值类型，将复制一份给克隆对象；如果原型对象的成员变量是引用类型，
     * 则将引用对象的地址复制一份给克隆对象，也就是说原型对象和克隆对象的成员变量指向相同的内存地址。
     * 所以浅拷贝引用成员类型值的修改会影响双方
     * 深拷贝实现很简单，就是让引用成员对象也实现clone方法,然后在主对象方法调用引用对象的clone即可。
     * @throws CloneNotSupportedException
     */
    @Override
    public UserEntity clone() throws CloneNotSupportedException {
        return (UserEntity)super.clone();
    }
}

	@Test
	public void testListObject() throws Exception {
		UserEntity user = new UserEntity();
		user.setName("大学森");
		user.setAge(23);
		user.setIsChina(true);
		user.setCreateTime(new Date());
		UserEntity user2 = new UserEntity();
		user2.setName("小学森2");
		user2.setAge(14);
		user2.setIsChina(true);
		user2.setCreateTime(new Date());
		UserEntity user3 = user2.clone();
		user3.setName("小学森");
		user3.setAge(15);
		UserEntity user4 = user3.clone();
		//对象拷贝，还可以用spring的BeanUtils.copyProperties().
		//BeanUtils.copyProperties利用反射，直接将对象的引用set进去，并不是深拷贝。
		//BeanUtils.copyProperties(object,tagerObject); copyProperties用起来方便，但性能和可控性不好

		List<UserEntity> userList = new ArrayList<>();
		userList.add(user);
		userList.add(user2);
		userList.add(user3);
		userList.add(user4);

		//去重
		HashSet<UserEntity> distinctSet = new HashSet<>();
		for(UserEntity ue : userList) {
			System.out.println(ue.hashCode());
			boolean success = distinctSet.add(ue);
			if(!success) {
				//重复数据处理
			}
		}
		//输出效果
		System.out.println("去重--------->");
		for(UserEntity u: distinctSet) {
			System.out.println(u);
		}

		//排序
		System.out.println("排序---------->");
		this.sortList(userList);
		for(UserEntity u : userList) {
			System.out.println(u);
		}
	}

	//排序
	private List<UserEntity> sortList(List<UserEntity> list) {
		Collections.sort(list,new Comparator<UserEntity>() {
			@Override
			public int compare(UserEntity o1, UserEntity o2) {
				//return o1.getName().compareTo(o2.getName());
				return o1.getAge().compareTo(o2.getAge());
			}
		});
		return list;
	}