Comparator和Comparable的区别

Comparable

这个需要比较的类自身实现这个接口，同时要实现这个接口的comparaTo方法，然后在这个方法里面自定义比较规则

然后调用Collections.sort方法传入要比较的集合对象进行比较，这里这个sort方法必须传入的是集合，而且要集合的原始类必须实现Comparable接口

注意事项

如果将comparTo方法的参数作为基准去比较，也就是将参数放在前面，这种是降序排列效果
如果将本身对象的参数作为基准去比较，也就是将本身参数放在前面，这种是升序排列效果
这里本身参数可以认为是o1，方法里面的参数是o2，那么与下面这种排序的效果是一致的
根据实际情况去处理到底用升序还是降序，

public class Person implements Comparable {
private String name;
private int age;

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 +
            '}';
}
//降序排列
@Override
public int compareTo(Object o) {
    Person tmp = (Person) o;
    int result = tmp.age > age ? 1 : (tmp.age==age ? 0 : -1);
    if (result == 0) {
        result = tmp.name.indexOf(0) > name.indexOf(0) ? 1 : -1;
    }
    return result;
}

//升序排列
  public int compareTo(Object o) {
    Person tmp = (Person) o;
    int result = age > tmp.age ? 1 : (age==tmp.age ? 0 : -1);
    if (result == 0) {
        result = tmp.name.indexOf(0) > name.indexOf(0) ? 1 : -1;
    }
    return result;
}

public static void main(String[] args) {
    List<Person> list=new ArrayList<>();
    list.add(new Person("jj",1));
    list.add(new Person("dsgfdsf",20));
    list.add(new Person("efefd",14));
    list.add(new Person("eftewf",11));

    Collections.sort(list); // 内部比较器:要排序的类实现Comparable接口,可以对自身进行比较
    System.out.println(list);
}

Comparator

这个不需要比较的类去实现接口，而是新创建一个类实现这个Comparator接口，然后实现他的compare方法

这里是通过一个外部比较器去比较，同样也是调用Collections.sort方法去比较，只不过此时这里要传两个参数，一个是集合，另外一个是自定义的比较器，
排序特点
当比较的是o1用来比较o2，即o1在前，o2在后，那么此时输出结果是升序的，反之
如果用o2比较o1，那么此时输出结果是降序的

public class StudentComparator implements Comparator {
//升序排法
//    @Override
//    public int compare(Object o1, Object o2) {
//        Student s1 = (Student) o1;
//        Student s2 = (Student) o2;
//        int result = s1.getAge() > s2.getAge() ? 1 : (s1.getAge() == s2.getAge() ? 0 : -1);
//        return result = result == 0 ? (s1.getSalary() > s2.getSalary() ? 1 : -1) : result;
//    
//降序排法
@Override
public int compare(Object o1, Object o2) {
    Student s1 = (Student) o1;
    Student s2 = (Student) o2;
    int result = s2.getAge() > s1.getAge() ? 1 : (s2.getAge() == s1.getAge() ? 0 : -1);
    return result = result == 0 ? (s2.getSalary() > s1.getSalary() ? 1 : -1) : result;
}

public static void main(String[] args) {
    List<Student> list=new ArrayList<>();
    Student student = new Student(20, 30.5);
    Student student2 = new Student(30, 30);
    Student student3 = new Student(40, 30);
    list.add(student);
    list.add(student2);
    list.add(student3);

    Collections.sort(list,new StudentComparator());
    System.out.println(list);
}
}

以上就是两种的区别和使用说明，本质升序和降序的比较顺序是一致的，就是o1o2就是升序，反之就是降序，，可以根据实际情况采用任意一种即可