Java比较器

基本数据类型需要比较大小的话,可以直接使用比较运算符,但是引用数据类型是不能直接使用比较运算符来比较大小的

自然排序

自然排序Comparable

如果数组中是基本数据类型的比较

@Test
public void test1() {
    String[] arr = new String[]{"Tom", "Jerry", "John", "Atom", "Bomb"};
    Arrays.sort(arr);
    for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i]);
    }
}

就能够使用Arrays.sort()来进行正常的排序

如果数组中的是引用数据类型,就会报错

@Test
public void test2() {
    Product[] arr = new Product[5];
    arr[0] = new Product("xiaomi", 1000);
    arr[1] = new Product("huawei", 2000);
    arr[2] = new Product("redmi", 500);
    arr[3] = new Product("oppo", 1500);
    arr[4] = new Product("vest", 1000);

    Arrays.sort(arr);
    for (Product product : arr) {
        System.out.println(product);
    }
}

那为什么String类型就可以排序呢?因为String类实现了Comparable接口

那同理,我们让Product类也实现Comparable接口,并实现抽象方法compareTo

/**
 * 当前的类需要实现Comparable中的抽象方法
 * 在此方法中如何判断当前类的对象的大小
 * 比如按照价格的高低进行大小的比较,或从低到高排序
 * 如果返回值是正数，则是调用方法的当前对象大
 * 如果返回值是0，则是一样大
 *
 * @param o the object to be compared.
 * @return
 */
@Override
public int compareTo(Object o) {
    if (o == this) {
        return 0;
    }
    if (o instanceof Product) {
        Product p = (Product) o;

        // 这个方法，如果前面大于后面，则返回1，反之则返回-1，如果相等，则返回0
        return Double.compare(this.price, p.price);
    }

    // 抛出异常
    throw new RuntimeException("类型不匹配");
}

此时就可以正常的使用Arrays.sort()来进行排序了

比较条件可以改为先比较价格，价格相同，进行名字的比较（从小到达）

// 比较标准：先比较价格，价格相同，进行名字的比较（从小到达）
    @Override
    public int compareTo(Object o) {
        if (o == this) {
            return 0;
        }
        if (o instanceof Product) {
            Product p = (Product) o;

            // 这个方法，如果前面大于后面，则返回1，反之则返回-1，如果相等，则返回0
            int result1 = Double.compare(this.price, p.price);
            // 不是0，则表示不相同，直接返回
            if (result1 != 0) {
                return result1;
            }

            // 价格相同，比name String已经重写过compareTo了，可以直接调用
            return this.name.compareTo(p.name);
        }

        // 抛出异常
        throw new RuntimeException("类型不匹配");
    }

如果想要从大到小排序,只需要在返回结果前面加上-即可

定制排序

定制排序Comparator

• 当元素的类型没有实现java.lang.Comparable接口而又不方便修改代码(例如:一些第三方的类,你只有.class文件,没有源文件)
• 如果一个类,实现了Comparable接口,也指定了两个对象的比较大小的规则,但是此时此刻我不想按照它预定义的方法比较大小,但是我又不能随意修改,因为会影响其他地方的使用,怎么办?

所以就有了这个Comparator接口,强行对多个对象进行整体排序的比较

• 重写compare(Object 01,Object 02)方法,比较o1,o2的大小,如果方法返回正整数,则表示o1大于o2,如果返回0,表示想等,返回负整数,表示o1小于o2
• 可以将Comparator传递给sort方法(如Collections.sort或Arrays.sort),从而允许在排序顺序上实现精确控制

使用匿名内部的形式实现

@Test
    public void test1() {
        Product[] arr = new Product[5];
        arr[0] = new Product("aiaomi", 1000);
        arr[1] = new Product("buawei", 2000);
        arr[2] = new Product("cedmi", 3000);
        arr[3] = new Product("dppo", 8000);
        arr[4] = new Product("eest", 8000);

        // 创建一个实现了Comparator接口的实现类的对象
        Comparator comparator = new Comparator() {
            // 如果要判断两个对象o1，o2的大小，其标准就是此方法体要编写的逻辑
            @Override
            public int compare(Object o1, Object o2) {
                if (o1 instanceof Product && o2 instanceof Product) {
                    Product p1 = (Product) o1;
                    Product p2 = (Product) o2;
                    int result1 = Double.compare(p1.getPrice(), p2.getPrice());
                    if (result1 != 0) {
                        return result1;
                    }
                    // 相同，则根据name从大到小排序
                    return -p1.getName().compareTo(p2.getName());
                }
                throw new RuntimeException("类型错误");
            }
        };

        // 如果不想用上面的比较器了，想实现一个只按name排序的，也非常灵活，可以直接再创建一个comparator
        Comparator comparator1 = new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                if (o1 instanceof Product && o2 instanceof Product) {
                    Product p1 = (Product) o1;
                    Product p2 = (Product) o2;
                    return p1.getName().compareTo(p2.getName());
                }
                throw new RuntimeException("类型错误");
            }
        };

        // 传入comparator对象
        Arrays.sort(arr, comparator);
        for (Product product : arr) {
            System.out.println(product);
        }
    }

此时就可以给String实现降序排序

@Test
public void test3() {
    // String默认就是从小到大排序的
    String[] arr = new String[]{"aaa", "bbb", "ccc", "ddd"};

    // 让String从大到小排序
    Comparator comparator = new Comparator() {
        @Override
        public int compare(Object o1, Object o2) {
            if (o1 instanceof String && o2 instanceof String) {
                String s1 = (String) o1;
                String s2 = (String) o2;
                return -s1.compareTo(s2);
            }
            throw new RuntimeException("类型错误");
        }
    };


    // lambda表达式写法
    Comparator comparator1 = (o1, o2) -> {
        if (o1 instanceof String && o2 instanceof String) {
            String s1 = (String) o1;
            String s2 = (String) o2;
            return -s1.compareTo(s2);
        }
        throw new RuntimeException("类型错误");
    };

    Arrays.sort(arr, comparator1);
    for (String s : arr) {
        System.out.println(s);
    }

    // 还可以直接在sort里面写lambda
    Arrays.sort(arr, (o1, o2) -> -o1.compareTo(o2));

    for (String s : arr) {
        System.out.println(s);
    }

}