JAVA中的比较器

引出

传统的对象之间是一般都是==或者！=
看对象是否为同一个
而没有存在>或者<类似的
但有的时候我们需要根据
对象的某一个属性进行排序
怎么办呢
这个时候就引出来
比较器了
主要是两个接口

Comparable和Comparator

Comparable
一般被成为自然排序（用途：一般是一个类继承接口重写compareTo方法，后面在集合或者其他地方排序的时候可以用）
Comparator
一般称为定制排序（用途：一般来给基本数据类型，或者比较次数较少的（一般是匿名内部类实现））

这两个都是要通过里面的compare方法来实现排序的，所以这个方法一定要重写

注意的：两者都是看retunrn的值,决定对应参数列表的排序
比如
compare(student o1,student o2)

return o1.score-o2.score
如果o1（7）的score大于o2（6）
返回正数
会判定o1排在o2后面（按照参数列表倒序）
此时就是正序  6-7
如果
return o2.score-o1.score
还看前面的数吧
返回是是一个-1，认定o1排在o2前面（按照参数列表o1后o2）
此时就编程倒序了 7-6

如果你是第一个参数减去第二个参数，永远是正序
（第一个参数大，第一个参数后排，第一个参数小，第一个参数前排）
反过来，第二个参数减第一个属性永远是倒序
不懂自己推一推

Cmoparable

Comparable是一个接口

此类常见于java中的Array和Collection的排列

调用Arrays/Collections.sort(对象数组/对象集合)

按照的排序方式就是对应对象内的重写Comparable类的ComparaTo方法

源码

public interface Comparable<T> 
{
    public int compareTo(T o);
}

使用举例

public class Goods implements  Comparable{

    private String name;
    private double price;

    //指明商品比较大小的方式:照价格从低到高排序,再照产品名称从高到低排序
    @Override
    public int compareTo(Object o) {
//        System.out.println("**************");
        if(o instanceof Goods){
            Goods goods = (Goods)o;
            //方式一：
            if(this.price > goods.price){
                return 1;
            }else if(this.price < goods.price){
                return -1;
            }else{
//                return 0;
               return -this.name.compareTo(goods.name);
               //解释一下吧，这里的this.name是一个String类型可以使用对应的方法
               //相当于 String.compareTo（这个String类重写过，默认从小到大排序按名称）
            }
            //方式二：
//           return Double.compare(this.price,goods.price);
        }
//        return 0;
        throw new RuntimeException("传入的数据类型不一致！");
    }
// getter、setter、toString()、构造器：省略
}

Comparator

1.背景：
当元素的类型没实现java.lang.Comparable接口而又不方便修改代码，或者实现了
java.lang.Comparable接口的排序规则不适合当前的操作，
那么可以考虑使用 Comparator 的对象来排序

2.重写compare(Object o1,Object o2)方法，比较o1和o2的大小：
如果方法返回正整数，则表示o1大于o2；
如果返回0，表示相等；
返回负整数，表示o1小于o2。

举例

Comparator com = new Comparator() {
    //指明商品比较大小的方式:照产品名称从低到高排序,再照价格从高到低排序
    @Override
    public int compare(Object o1, Object o2) {
        if(o1 instanceof Goods && o2 instanceof Goods){
            Goods g1 = (Goods)o1;
            Goods g2 = (Goods)o2;
            if(g1.getName().equals(g2.getName())){
                return -Double.compare(g1.getPrice(),g2.getPrice());
            }else{
                return g1.getName().compareTo(g2.getName());
            }
        }
        throw new RuntimeException("输入的数据类型不一致");
    }
}

使用：
Arrays.sort(goods,Comparator);
Collections.sort(coll,Comparator);
new TreeSet(com);
//comparator一般是用匿名内部类实现
//8后可以用lambda表达式实现 (o1,o2)-> o1.getXXX()-o2.getXXX()
//省略了return 和 {} 和 参数类型

两者区别可以看
Comparable和Comparator区别

集合基本数据类型排序

@SuppressWarnings("all")
public class Main{

public static void main(String [] args){
	Scanner scanner = new Scanner(System.in);
	int a=scanner.nextInt();
	int b=scanner.nextInt();
	int c=scanner.nextInt();
	ArrayList<Integer> arrayList = new ArrayList<Integer>();
	arrayList.add(a);
	arrayList.add(b);
	arrayList.add(c);
	arrayList.sort(new Comparator<Integer>() {

		@Override
		public int compare(Integer o1, Integer o2) {
			return o1-o2;
		}
		
	});
	for (Integer integer : arrayList) {
		System.out.println(integer);
	}
}
}