java中的比较器

前言

Java中的对象，正常情况下，只能进行比较：== 或 != 。不能使用 > 或 < 的。 但是在开发场景中，我们需要对多个对象进行排序，言外之意，就需要比较对象的大小。
只要我们在程序中，遇到要给对象比较大小的，肯定要和下面两个接口打交道。

instanceof

判断一个对象是否为指定类的实例，往往用在传入对象是Object的情况下
比如：

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("输入的数据类型不一致");
}

自然排序 Comparable

让类本身去实现comparable接口，这个类中就实现了Comparable接口中的compareTo方法，并且默认为从小到大的排序方式。
举例：
String类中就实现了Comparable接口，有源码为证：

Comparable接口的特点

Compareable接口被各种包装类以及String类实现。
类中的comapareTo方法可以在其他适合的地方随意调用。

具体使用

可以实现多个属性的对比
比如说：现在有一个Goods类，其本身具有价格与产品名称两个属性
现在要求其实现先按照价格从低到高，再按照产品名称从高到低排序，Goods类实现了Comparable接口，并重写CompareTo方法

public int CompareTo(Object o)
{
	if(this.price>o.price)
	{
		return 1;
	}
	else if(this.price<o.price)
	{
		return -1;
	}
	else
	{
	  return -this.name.compareTo(goods.name);
	}
}

上面最后一句话其实我看不懂，是由于String方法实现了Comparable接口所以name才能调用compareTo方法。

定制排序 Comparator

什么时候使用Comparator类

当元素的类型没有实现java.lang.Comparable接口而又不方便修改代码，或者实现了java.lang.Comparable接口的排序规则不适合当前的操作，那么可以考虑使用 Comparator 的对象来排序
我们基本上常常用在有的类没有实现comparable接口的时候

重写Compare方法

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

两种接口的对比

Comparable接口的方式一旦一定，保证Comparable接口实现类的对象在任何位置都可以比较大小。
Comparator接口属于临时性的比较。

与Arrays.sort()方法的结合。

我们一旦涉及到比较，肯定是多个数的比较，那么多个数肯定是放在一个容器中进行比较的，很多情况下这个容器就是数组，所以很多情况下，我们都自然而然的想到会用Arrays.sort()进行排序。
那么Arrays.sort()比较的对象呢，如果缺省第二个参数，则会使用对象类中实现的compareable接口的CompareTo方法逻辑进行比较。如果该自定义对象类，没有实现Comparable接口的话，直接利用Arrays.sort()进行比较是会出错的。
举个例子：

对象类(我们故意让其没有实现Comparable接口)

public class Goods {

    private String name;
    private double price;

    public Goods() {
    }

    public Goods(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

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

测试代码

public void test2(){
        Goods[] arr = new Goods[5];
        arr[0] = new Goods("lenovoMouse",34);
        arr[1] = new Goods("dellMouse",43);
        arr[2] = new Goods("xiaomiMouse",12);
        arr[3] = new Goods("huaweiMouse",65);
        arr[4] = new Goods("microsoftMouse",43);

        Arrays.sort(arr);

        System.out.println(Arrays.toString(arr));
    }

执行单元测试时会出现

还有一种方式，加入第二个参数进行比较操作，使用定制排序接口Comparator

    public void test3(){
        String[] arr = new String[]{"AA","CC","KK","MM","GG","JJ","DD"};
        Arrays.sort(arr,new Comparator(){

            //按照字符串从大到小的顺序排列
            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof String && o2 instanceof  String){
//                    String s1 = (String) o1;
                    String s1= (String) o1;
                    String s2 = (String) o2;
                    return -s1.compareTo(s2);
                }
//                return 0;
                throw new RuntimeException("输入的数据类型不一致");
            }
        });
        System.out.println(Arrays.toString(arr));
    }

我们一般在这种情况下，喜欢使用匿名内部类的方式去实现。但是Compatator内部再进行比较的时候，有一个巨大的缺陷，只能使用引用类，而对于普通的基本数据类型是不能进行比较的。