Java学习之简述Comparable和Comparator两个接口

前言

说到排序，简单的说就是两个对象之间比较大小，那么在JAVA中提供了两种比较实现的方式，一种是比较死板的采用 java.lang.Comparable 接口去实现，一种是灵活的当我需要做排序的时候在去选择的java.util.Comparator 接口完成

1.Collections常用功能

java.utils.Collections 是集合工具类，用来对集合进行操作。部分方法如下：

• public static boolean addAll(Collection c, T… elements) :往集合中添加一些元素。
• public static void shuffle(List<?> list) 打乱顺序 :打乱集合顺序。
• public static void sort(List list) :将集合中元素按照默认规则排序。
• public static void sort(List list，Comparator<? super T> ) :将集合中元素按照指定规则排序

这里排序问题就涉及到Comparable与Comparator两个接口，详细介绍与代码案例如下：

2. Comparable与Comparator两者比较

• Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的【自然排序】，类的compareTo方法被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。
  实现此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。

• Comparator强行对某个对象进行整体排序，即【定制排序】。
  可将Comparator 传递给sort方法（如Collections.sort或Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序

3.案例分析

3.1默认自然排序顺序

public class CollectionsDemo {
public static void main(String[] args) {
	ArrayList<Integer> list = new ArrayList<Integer>();
	//原来写法
	//list.add(12);
	//list.add(14);
	//list.add(15);
	//list.add(1000);
	//采用工具类完成往集合中添加元素
	Collections.addAll(list, 5, 222, 1，2);
	System.out.println(list);
	//排序方法
	Collections.sort(list);
	System.out.println(list);
	}
} 
结果：
[5, 222, 1, 2]
[1, 2, 5, 222]

我们观察一下sort()方法的源码：

@SuppressWarnings("unchecked")
public static <T extends Comparable<? super T>> void sort(List<T> list) {
        list.sort(null)
    }
    
@SuppressWarnings({"unchecked", "rawtypes"})
    public static <T> void sort(List<T> list, Comparator<? super T> c) {
        list.sort(c);
    }

这里就有许多疑问，为什么调用的是第一个默认排序sort()方法？
原来这些基本数据类型默认实现了Comparable接口

public final class Integer extends Number implements Comparable<Integer>{......}

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {......}

3.2 定制排序

但是这样就把这种规则写死了，那比如我想要字符串按照第一个字符降序排列，那么这样就要修改String的源代码，这是不可能的了，那么这个时候我们可以使用public static void sort(List list，Comparator<? super T> ) 方法灵活的完成，这个里面就涉及到了Comparator这个接口，位于位于java.util包下，排序是comparator能实现的功能之一,该接口代表一个比较器，比较器具有可比性！顾名思义就是做排序的，通俗地讲需要比较两个对象谁排在前谁排在后，那么比较的方法就是：

• public int compare(String o1, String o2) ：比较其两个参数的顺序

两个对象比较的结果有三种：大于，等于，小于。
如果要按照升序排序， 则o1 小于o2，返回（负数），相等返回0，o1大于o2返回（正数） 如果要按照降序排序 则o1 小于o2，返回（正数），相等返回0，o1大于o2返回（负数）

public class CollectionsDemo3 {
public static void main(String[] args) {
	ArrayList<String> list = new ArrayList<String>();
	list.add("cba");
	list.add("aba");
	list.add("sba");
	list.add("nba");
	//定制排序方法 按照第一个单词的降序
	Collections.sort(list, new Comparator<String>() {
			@Override
			public int compare(String o1, String o2) {
				return o2.charAt(0) ‐ o1.charAt(0);
			}
		});
		System.out.println(list);
	}
}
结果如下：
[sba, nba, cba, aba]

4.拓展

如果想要自己创建的实体中的元素完成排序，那么必须要实现比较器Comparable接口。于是我们就完成了Student类的一个实现，如下：

4.1定义实体类

public class Student implements  Comparable<Student> {
    private Integer id;
    private String name;
    private Integer age;

    public Student(Integer id, String name, Integer age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

	//此处略写getter、setter、toString方法
	
	//按学生年龄升序排序
    @Override
    public int compareTo(Student o) {
        return this.age-o.age;
    }
}

向集合添加数据:

 public static List<Student> setList(){
        ArrayList<Student> list=new ArrayList<>();
        Student st1=new Student(1,"迪丽热巴",20);
        Student st2=new Student(2,"杨幂",21);
        Student st3=new Student(3,"古力娜扎",19);
        Student st4=new Student(4,"关晓彤",18);
        Collections.addAll(list,st1,st2,st3,st4);
        return list;
    }
    
    public  static void printDefault(List<Student> list){
        System.out.println("1.初始存入顺序：");
        System.out.println(list);
    }

private static void printSortByage(List<Student> list) {
        Collections.sort(list);//此处为默认排序
        System.out.println("2.Comparable接口，自然按年龄升序排序：");
        System.out.println(list);
        System.out.println("3.Comparator方法重写，指定按ID倒序排序：");
        //此处还可进行内部类方法重写Comparator方法，按Id排序
        Collections.sort(list, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o2.getId()-o1.getId();
            }
        });
        System.out.println(list);
    }

最终main方法体：

public class Domain {
    public static void main(String[] args) {
        List<Student> students = setList();
        printDefault(students);
        printSortByage(students);
    }
    
结果如下:
1.初始存入顺序：
[Student{id=1, name='迪丽热巴', age=20}, Student{id=2, name='杨幂', age=21}, Student{id=3, name='古力娜扎', age=19}, Student{id=4, name='关晓彤', age=18}]

2.Comparable接口，自然按年龄升序排序：
[Student{id=4, name='关晓彤', age=18}, Student{id=3, name='古力娜扎', age=19}, Student{id=1, name='迪丽热巴', age=20}, Student{id=2, name='杨幂', age=21}]

3.Comparator方法重写，指定按ID倒序排序：
[Student{id=4, name='关晓彤', age=18}, Student{id=3, name='古力娜扎', age=19}, Student{id=2, name='杨幂', age=21}, Student{id=1, name='迪丽热巴', age=20}]