Set 中Comparable 和 Comparator 的区别

Comparable 接口和 Comparator 接口都是 Java 中用于排序的接口，它们在实现类对象之间比较大小、排序等方面发挥了重要作用：

• Comparable 接口实际上是出自java.lang包 它有一个 compareTo(Object obj)方法用来排序

• Comparator接口实际上是出自 java.util 包它有一个compare(Object obj1, Object obj2)方法用来排序

一般我们需要对一个集合使用自定义排序时，我们就要重写compareTo()方法或compare()方法，当我们需要对某一个集合实现两种排序方式.

注意要点:

1.实现Comparator接口后,怎么重写compare()方法?

使用了 Java 中 Integer 类的内置比较功能,简洁明了地实现了降序排列的逻辑。

2.实现Comparable 接口后,加了泛型(Person).

package com.Luo.Demo2;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

/**
 * @ClassName:
 * @Description: Comparator 定制排序
 * @Author:luo
 */
public class Demo1 {
    public static void main(String[] args) {
        ArrayList<Integer> arrayList = new ArrayList<Integer>();
        arrayList.add(-1);
        arrayList.add(3);
        arrayList.add(3);
        arrayList.add(-5);
        arrayList.add(7);
        arrayList.add(4);
        arrayList.add(-9);
        arrayList.add(-7);
        System.out.println("原始数组:");
        System.out.println(arrayList);
        // void reverse(List list)：反转
        Collections.reverse(arrayList);
        System.out.println("反转原始数组:");
        System.out.println(arrayList);
         void sort(List list),按自然排序的升序排序
        Collections.sort(arrayList);
        System.out.println("按自然排序的升序排序:");
        System.out.println(arrayList);
         定制排序的用法
        Collections.sort(arrayList, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2.compareTo(o1);
            }
        });
        System.out.println("定制排序后：");
        System.out.println(arrayList);


    }

}
package com.Luo.Demo2;

import java.util.Set;
import java.util.TreeMap;

/**
 * @ClassName:
 * @Description: 重写 compareTo 方法实现按年龄来排序
 * @Author:luo
 */
public class Demo2 {
    public static void main(String[] args) {
        TreeMap<Person, String> map = new TreeMap<>();
        map.put(new Person("张三", 30), "zhangsan");
        map.put(new Person("李四", 20), "lisi");
        map.put(new Person("王五", 10), "wangwu");
        map.put(new Person("小红", 5), "xiaohong");

        Set<Person> keySet = map.keySet();
        for (Person key : keySet) {
            String name = map.get(key);
            System.out.println(key + "==" + name);
        }


    }

}

class Person implements Comparable<Person> {
    private String name;
    private int age;

    public Person() {
    }

    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;
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    // 如果返回值为正数，则表示当前对象大于参数对象；
    // 如果返回值为负数，则表示当前对象小于参数对象；
    // 如果返回值为零，则表示两个对象相等。
    // 因此，这段代码是按照升序排列的逻辑来实现的。
    // 如果想要实现降序排列，只需在返回值处做相反的处理即可，即将 return 1; 改为 return -1;，将 return -1; 改为 return 1;。

    @Override
    public int compareTo(Person o) {
        if (this.age > o.getAge()) {
            return 1;
        }
        if (this.age < o.getAge()) {
            return -1;
        }
        return 0;

    }
}