java compare排序 java comparator排序顺序

Java比较器

Java中常涉及到对象的排序问题，即涉及对象之间的比较。

Java实现对象排序有两种方式：

1. 自然排序：java.lang.Comparable。
2. 定制排序：java.util.Comparator。

方式一：Comparable

Comparale接口强行对实现他的每个类的对象进行整体排序，这种排序成为类的自然排序。

步骤：

1. 需要排序的的对象对应的类实现Comparable接口。
2. 重写compareTo()，两个对象即可通过compareTo(Object o)的返回值来比较大小。
3. 比较规则：当前对象this大于形参对象o，则返回正整数1，如果当前对象this小于形参对象o，则返回负整数-1，如果当前对象this等于形参对象o，则返回0。
4. 实现Comparable接口的对象列表（或数组）可以通过Collections.sort()和Arrays.sort()进行排序。

示例：Book类

/**
 * 商品类
 *
 * @Author：xiezr
 * @Creat：2021-07-13 14:29
 */
public class Book implements Comparable{
    private String name;    // 名称
    private double price;   // 价格
    public Book(){

    }
    public Book(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 "Book{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}' +
                '\n';
    }

    // 按照价格从低到高排序,在按照书本的名称从低到高排序。（按照重写的规则进行排序）
    @Override
    public int compareTo(Object o) {
        if (o instanceof Book){
            Book b1 = (Book) o;
            if (this.price > b1.price){
                return 1;
            }else if (this.price < b1.price){
                return -1;
            }else {
                // 价格相同时，按照名称排序
                return this.name.compareTo(((Book) o).name);
            }
        }
        throw new RuntimeException("价格错误");
    }
}

测试：

// 实现Comparable接口
    @Test
    public void test1(){
        Book[] com = new Book[4];
        com[0] = new Book("《向着光亮的地方》",42);
        com[1] = new Book("《谁的青春不迷茫》",35);
        com[2] = new Book("《你的孤独 虽败犹荣》",39.80);
        com[3] = new Book("《好吗 好的》",35);

        Arrays.sort(com);
        System.out.println(Arrays.toString(com));
    }

---

方式二：Comparator

当元素的类没有实现java.lang.Comparable接口而又不方便修改代码或者实现了java.lang.Comparable接口的排序规则不适合当前操作，那么可以考虑使用Comparator对象来排序，强行对多个对象进行排序的比较。

步骤：

1. 创建一个Comparator接口的实现类，暂且叫做ComparatorTest。（使用一次的话可以使用匿名内部类）
2. 重写compare(Object o1,Object o2)。
3. 创建ComparatorTest的对象，暂且叫做comparator
4. 将需要排序比较的对象和comparator，一起作为参数传进Arrays.sort()或者Collections.sort()中即可。

示例：

ComparatorTest类：

/**
 * 给Book的对象定制另一种排序方式
 * 先按名称从高到低排序，再按价格从高到低排序。
 *
 * @Author：xiezr
 * @Creat：2021-07-13 16:14
 */
public class ComparatorTest implements Comparator {

    //
    @Override
    public int compare(Object o1, Object o2) {
        if (o1 instanceof Book && o2 instanceof Book){
            // 传入的Object转换成对应的类型
            Book b1 = (Book) o1;
            Book b2 = (Book) o2;
            if (b1.getName().equals(b2.getName())){
                if (b1.getPrice() > b2.getPrice()){
                    return -1;
                }

                if (b1.getPrice() < b2.getPrice()){
                    return 1;
                }else {
                    return 0;
                }
            }else {
                return -b1.getName().compareTo(b2.getName());
            }
        }
        throw new RuntimeException("输入有误");
    }
}

测试：

// 方式二：实现Comparator接口
    @Test
    public void test2(){
        Book[] com = new Book[5];
        ComparatorTest comparator = new ComparatorTest();
        com[0] = new Book("《Towards the light》",42);
        com[1] = new Book("《Towards the light》",45);
        com[2] = new Book("《Whose youth is not confused》",35);
        com[3] = new Book("《Your loneliness is glorious even if you are defeated》",39.80);
        com[4] = new Book("《Okay? Okay》",39);

        Arrays.sort(com,comparator);
        System.out.println(Arrays.toString(com));
    }
}