问题

常见的基本数据类型 int char 这种可以进行比较排序，那么引用数据类型（对象）该怎么进行排序呢？

有两种方法，自然排序（Comparable）、定制排序（Comparator）

方式一

在需要比较的类实现Comparable接口，实现compareTo方法。

public class ComparableTest {
    public static void main(String[] args) {
        //基本数据类型的比较
        String[] arr=new String[]{"Tom","Jerry","Tony","Rose","Jack"};
        Arrays.sort(arr);
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

        //创建几个对象
        Product[] parr=new Product[5];
        parr[0]=new Product("红米手机",1999);
        parr[1]=new Product("vivo手机",5999);
        parr[2]=new Product("小米手机",5999);
        parr[3]=new Product("华为手机",6999);
        parr[4]=new Product("苹果手机",9999);

        Arrays.sort(parr);
        for (int i = 0; i < parr.length; i++) {
            System.out.println(parr[i]);
        }

        //直接比较对象的话，就直接使用compareTo方法
        int i = parr[0].compareTo(parr[3]);
        System.out.println(i);

    }
}
class Product implements Comparable{
    private String name;
    private double price;

    public Product(String name, int price) {
        this.name = name;
        this.price = price;
    }

    public Product() {
    }

    public String getName() {
        return name;
    }

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

    public double getPrice() {
        return price;
    }

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

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

    //实现Comparable的 compareTo 抽象方法
    //指明如何比较大小，比如按照价格的高低进行排序（从低到高）
    //一样大返回0 ， 大返回正数 ，小返回负数
    @Override
    public int compareTo(Object o) {
        if(o==this){
            return 0;
        }
        if(o instanceof Product){
            //强转为需要比较的类
            Product p=(Product) o;
            int compare = Double.compare(this.price, p.price);
            //如果价格相同再比较一下它们的名字
            if(compare==0){
                return this.name.compareTo(p.name);
            }else {
                return compare;
            }
        }
        throw new RuntimeException("类型不匹配");
    }
}

方式二 Comparator

需求场景

1. 需要的类没有实现Comparable接口的情况下，不方便修改源码就要使用Comparator方法了
2. 已经实现了Comparable接口但是自己不想使用它的排序规则

步骤：

1. 创建一个实现了Comparator接口的对象
2. 实现类要求实现了Comparator接口中的compare（Object o1，Object o2）方法，在方法中指明如何比较大小
3. 创建此实现类的对象，并将此对象传入到相关方法的参数位置

comparator作为一个比较器 生成一个对象放在Arrays.sort（arr，comparator）中作为参数来进行排序

public class ComparatorTest {
    public static void main(String[] args) {
        //创建几个对象
        Product[] parr=new Product[5];
        parr[0]=new Product("红米手机",1999);
        parr[1]=new Product("vivo手机",5999);
        parr[2]=new Product("小米手机",5999);
        parr[3]=new Product("华为手机",6999);
        parr[4]=new Product("苹果手机",9999);

        //创建一个实现了Comparator接口实现类的对象
        Comparator cp=new Comparator() {
            //如何判断两个对象的大小，就是此方法的方法体
            @Override
            public int compare(Object o1, Object o2) {
                if(o1==o2){
                    return 0;
                }
                if(o1 instanceof Product&&o2 instanceof Product){
                    Product p1=(Product) o1;
                    Product p2=(Product) o2;
                    return Double.compare(p1.getPrice(),p2.getPrice());
                }
                throw new RuntimeException("类型不匹配");
            }
        };

        //创建一个实现了Comparator接口实现类的对象,用名字来排序
        Comparator cp2=new Comparator() {
            //如何判断两个对象的大小，就是此方法的方法体
            @Override
            public int compare(Object o1, Object o2) {
                if(o1==o2){
                    return 0;
                }
                if(o1 instanceof Product&&o2 instanceof Product){
                    Product p1=(Product) o1;
                    Product p2=(Product) o2;
                    return p1.getName().compareTo(p2.getName());
                }
                throw new RuntimeException("类型不匹配");
            }
        };

        Arrays.sort(parr,cp2);

        for (int i = 0; i <parr.length ; i++) {
            System.out.println(parr[i]);
        }
    }
}

两种方式的对比