Comparable 和comparator

(1) Comparable的用法

对于集合里面的自定义对象，如果想对他们排序,只需三步:
(1)先实现java.lang.Comparable接口;
(2)并实现里里面的比较接口compareTo(Object o);
(3)然后我们只要调用公共类库java.util.Collections这个类的sort(List list)方法，Java就会按照它的一套方法对list集合里面的对象排列先后次序.示例如下:

public class Student implements Comparable<Student> {
    private int id;
    private String name;
    private int 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 int compareTo(Student o) {
        return new Integer(age).compareTo(new Integer(o.getAge()));
    }
}

public static void main(String[] args) {

        List<Student> studentList=new ArrayList<Student>();

        Student student=new Student();
        student.setName("lili_3");
        student.setAge(13);
        studentList.add(student);

        Student student_one=new Student();
        student_one.setName("lili");
        student_one.setAge(12);
        studentList.add(student_one);

        Student student_two=new Student();
        student_two.setName("lili_2");
        student_two.setAge(10);
        studentList.add(student_two);

        Collections.sort(studentList);
    }

(2) Comparator的用法

在现实生活中我们会遇到这样一个问题就是同样一种类型的对象之间可能会按着不同的规则进行排序,
(1)Java里面给我们提供了一个比较器java.util.Comparator，我们只要在比较器中定义它所比较的两个对象之间的比较规则即可。
(2)然后同样调用公共类库中java.util.Collections这个类的sort(List list, Comparator c)方法,或者使用TreeMap容器排序都可以;

public class CartItemDTO {

    private SkuDTO sku;

    private Long lastUpdateTime;


    public Long getLastUpdateTime() {
        return lastUpdateTime;
    }

    public void setLastUpdateTime(Long lastUpdateTime) {
        this.lastUpdateTime = lastUpdateTime;
    }
}

public class SkuDTO {
    /**
     * 商品ID
     */
    private Long itemId;

    /**
     * 卖家Id
     */
    private Long sellerUserId;

    public Long getItemId() {

        return itemId;
    }
    public void setItemId(Long itemId) {
        this.itemId = itemId;
    }
    public Long getSellerUserId() {
        return sellerUserId;
    }

    public void setSellerUserId(Long sellerUserId) {
        this.sellerUserId = sellerUserId;
    }
}

public class sortImpl {
    public Map<Long, List<CartItemDTO>> getSortCartItem(List<CartItemDTO> cartItemDTOs) {
        //按店铺分组
        Map<Long, List<CartItemDTO>> sellerUserMap = sortBySellerUser(cartItemDTOs);
        //根据店铺内商品最新更新时间排序
        GroupSortCartComparator groupSortCartComparator = new GroupSortCartComparator(sellerUserMap);
        //第一种:容器排序
        TreeMap<Long, List<CartItemDTO>> sellerMap = new TreeMap<Long, List<CartItemDTO>>(groupSortCartComparator);
        sellerMap.putAll(sellerUserMap);
        //店铺内排序 按照商品更新时间排序
        SkuComparator skuComparator = new SkuComparator();
        for (Map.Entry<Long, List<CartItemDTO>> pair : sellerUserMap.entrySet()) {
                //第二种排序
            **Collections.sort(pair.getValue(), skuComparator);**
        }
        }
        return sellerUserMap;
    }

    /**
     * 按照店铺分组
     *
     * @param cartItemDTOs
     * @return
     */
    public Map<Long, List<CartItemDTO>> sortBySellerUser(List<CartItemDTO> cartItemDTOs) {
        Map<Long, List<CartItemDTO>> sellerUserMap = new HashMap<Long, List<CartItemDTO>>();
        for (CartItemDTO cartItemDTO : cartItemDTOs) {
            Long sellerUserId = cartItemDTO.getSku().getSellerUserId();
            if (sellerUserMap.containsKey(sellerUserId)) {
                sellerUserMap.get(sellerUserId).add(cartItemDTO);
            } else {
                List<CartItemDTO> cartItemList = new ArrayList<CartItemDTO>();
                cartItemList.add(cartItemDTO);
                sellerUserMap.put(sellerUserId, cartItemList);
            }
        }
        return sellerUserMap;

    }


    /**
     * 自定义比较器 根据店铺内商品最新更新时间排序
     */

    class GroupSortCartComparator implements Comparator<Long> {

        public Map<Long, List<CartItemDTO>> base;

        public GroupSortCartComparator(Map<Long, List<CartItemDTO>> cartItem) {
            this.base = cartItem;

        }

        @Override
        public int compare(Long o1, Long o2) {
            List<CartItemDTO> cartItemDTOs_one = base.get(o1);
            List<CartItemDTO> cartItemDTOs_two = base.get(o2);

            Long lastUpdateTime_one = getLastUpdateTime(cartItemDTOs_one);
            Long lastUpdateTime_two = getLastUpdateTime(cartItemDTOs_two);
            if (lastUpdateTime_one < lastUpdateTime_two) {
                return 1;
            } else {
                return -1;
            }
        }
    }

    /**
     * 获取店铺中商品的最新更新时间
     *
     * @param cartItemDTOList
     * @return
     */
    public Long getLastUpdateTime(List<CartItemDTO> cartItemDTOList) {

        Long lastUpdateTime = 0L;
        if (cartItemDTOList.get(0).getLastUpdateTime() != null) {
            lastUpdateTime = cartItemDTOList.get(0).getLastUpdateTime();
        }
        for (CartItemDTO cartItemDTO : cartItemDTOList) {
            Long updateTime = cartItemDTO.getLastUpdateTime() != null ? cartItemDTO.getLastUpdateTime() : 0L;
            if (lastUpdateTime < updateTime) {
                lastUpdateTime = updateTime;
            }

        }
        return lastUpdateTime;


    }

    /**
     * 对店铺内的商品按照商品的更新时间排序
     */
    class SkuComparator implements Comparator<CartItemDTO> {
        @Override
        public int compare(CartItemDTO o1, CartItemDTO o2) {
            Long updateTime_one = o1.getLastUpdateTime();
            Long updateTime_two = o2.getLastUpdateTime();
            if (updateTime_one < updateTime_two) {
                return 1;
            } else {
                return -1;
            }

        }
    }


}