比较器 Comparator

Comparable接口的主要特征是在类定义的时候就默认实现好的接口，那么如果说现在有一个类已经开发完善了。

class Book{
    private String title;
    private double price;
    public Book(){}

    public Book(String title,double price){
        this.title=title;
        this.price=price;
    }
    @Override
    public String toString() {
        return "BookName:"+this.title+"price:"+this.price;
    }

    /**
     * @param price the price to set
     */
    public void setPrice(double price) {
        this.price = price;
    }
    /**
     * @param title the title to set
     */
    public void setTitle(String title) {
        this.title = title;
    }
    /**
     * @return the price
     */
    public double getPrice() {
        return price;
    }
    /**
     * @return the title
     */
    public String getTitle() {
        return title;
    }
}

以上就是初步完善的Book类

但是由于初期的设计并没有安排此类对象数组的排序。而后又突然需要实现对象数组的排序，在不能修改Book类定义情况下，是不可能使用Comparable接口的，为此出现了另外一个比较器:java.util.Comparator.（外部比较器）。原本在Comparator接口下定义了两个方法

这是一个函数式接口。所以现在看起来就一个方法

@FunctionalInterface
public interface Comparator<T>{
        public int compare(T o1,T o2);
        public boolean equals(Object obj);
}

实际上，我们要实现的compare方法，我们只需要单独准备出一个类来实现这个接口的方法，来作为我们指定的排序类

范例:定义排序的工具类(Book类之外定义的外部排序类)并且实现排序

package TestDemo;


import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Comparator;
import java.util.Date;

import javax.lang.model.util.ElementScanner6;



class Book{
    private String title;
    private double price;
    public Book(){}

    public Book(String title,double price){
        this.title=title;
        this.price=price;
    }
    @Override
    public String toString() {
        return "BookName:"+this.title+"price:"+this.price;
    }

    /**
     * @param price the price to set
     */
    public void setPrice(double price) {
        this.price = price;
    }
    /**
     * @param title the title to set
     */
    public void setTitle(String title) {
        this.title = title;
    }
    /**
     * @return the price
     */
    public double getPrice() {
        return price;
    }
    /**
     * @return the title
     */
    public String getTitle() {
        return title;
    }
}

class BookComparator implements Comparator<Book>{
    @Override
    public int compare(Book o1, Book o2) {
        if(o1.getPrice()>o2.getPrice()) {
            return 1;}
        else if(o1.getPrice()<o2.getPrice()){
         return -1;}
        else{
             return 0;}
    }
}


public class TestDemo{
    
    public static void main(String[] args) throws Exception{
            Book books []=new Book[]{
                new Book("Java", 11.1),
                new Book("JSP",22.2),
                new Book("Android",33.3)
            };

            Arrays.sort(books,new BookComparator());
            System.out.println(Arrays.toString(books));
            
    }   


}

的确实现了排序。

之前使用Comparable接口的时候利用的是Arrays类中的sort()方法，可是现在更换了一个接口之后，也可以使用另外一个被重载的sort方法。
public static <T> void sort(T[] a ,Comparator<?super T> c) 相当于泛型下限（Comparator及其实现子类）都可以作为第二参数传入，表示排序规则，第一个参数传入对象数组。

总结:
使用Comparator比较麻烦，因为要定义一个专门的排序类，而且调用排序的时候也要明确的指明排序规则类，所以比较器99％都会使用Comparable。

请解释Comparable和Comparator的区别?
1.如果对象数组要进行排序那么必须设置排序规则，可以使用Comparable或者Comparator接口实现
2.java.lang.Comparable是在一个类定义的时候，实现好的接口，这样本类的对象数组就能够进行排序，所以属于内部比较器，只需覆写compareTo()方法即可。
而java.util.Comparator是专门定义一个指定类的比较规则，属于挽救的比较操作，属于外部比较器。

总结:

以后不管何种情况下，只要牵扯到对象数组的排序，一定要使用Comparable接口。