Java 常用类的知识点 二

Java 比较器

package ComparableAndComparator;

import org.junit.jupiter.api.Test;

import java.util.Arrays;
import java.util.Comparator;

/**
 *
 *      Comparable 接口的使用举例： 自然排序
 *  1 像 String、包装类等都实现了Comparable接口，重写了CompareTo（obj）方法，给出了比较两个对象大小的方式
 *  2 像 String、包装类重写compareTo（）方法以后，进行了从小到大的排序
 *  3 重写compareTo（obj）的规则：
 *      如果当前对象this 大于形参对象obj，则返回正整数，
 *      如果当前对象this 小于形参对象obj，则返回负整数；
 *      如果当前对象this 等于形参对象obj，则返回零。
 *
 *  4 对于自定义类来说，如果需要排序，我们可以让自定义类实现Comparable 接口，重写compareTo方法
 *    在CompareTo（obj）方法中指明如何排序
 *
 *
 */
public class CompareTest {

    @Test
    public void Test1(){
        String[] arr = new String[]{"AA","FF","DD","ZZ","BB"};
        //其实在sort里面也是重写了compareTo的方法啊
        Arrays.sort(arr);

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

    @Test
    public void Test2() {
        Goods[] GA = new Goods[5];
        GA[0] = new Goods("lenovoMouse",34);
        GA[1] = new Goods("dellMouse",43);
        GA[2] = new Goods("xiaomiMouse",12);
        GA[3] = new Goods("lenovoMouse",65);
        GA[4] = new Goods("huaweiMouse",65);

        Arrays.sort(GA);


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


    /**
     *
     * Comparator 接口的使用： 定制排序
     * 1：背景
     * 当元素的类型没有实现java.lang.Comparable接口而又不方便修改代码，
     * 或者实现了java.lang.Comparable接口的排序规则不适合当前的操作，
     * 那么可以考虑使用 Comparator 的对象来排序
     *
     * 2：方式
     * 重写compare(Object o1,Object o2)方法，比较o1和o2的大小:
     * 如果方法返 回正整数，则表示o1大于o2;
     * 如果返回0，表示相等;
     * 返回负整数，表示 o1小于o2
     */


    @Test
    public void Test3(){
        String[] arr = new String[]{"AA","FF","DD","ZZ","BB"};

        Arrays.sort(arr, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                if (o1 instanceof Object && o2 instanceof Object) {
                    String s1 = (String) o1;
                    String s2 = (String) o2;

                    return -s1.compareTo(s2);
                }
                throw new RuntimeException("输入不一致");
            }
        });
        System.out.println(Arrays.toString(arr));
    }

    @Test
    public void Test4(){
        Goods[] GA = new Goods[5];
        GA[0] = new Goods("lenovoMouse",34);
        GA[1] = new Goods("dellMouse",43);
        GA[2] = new Goods("xiaomiMouse",12);
        GA[3] = new Goods("lenovoMouse",65);
        GA[4] = new Goods("huaweiMouse",65);

        Arrays.sort(GA, new Comparator() {
            //指明商品比较大小的方式：先按照产品名称从低到高，再按照价格
            @Override
            public int compare(Object o1, Object o2) {
                if (o1 instanceof Object && o2 instanceof Object) {
                    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());
                    }
                }
                return 0;
            }
        });


        System.out.println(Arrays.toString(GA));

    }

}


// 创建一个Goods类测试
class Goods implements Comparable{
    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 +
                '}';
    }

    //指明商品按照什么排序
    //按照价格排序
    @Override
    public int compareTo(Object o){
        if (o instanceof Goods) {
            Goods goods = (Goods)o;
            //方式一
            if (this.price > goods.price) {
                return 1;
            }else if (this.price < goods.price) {
                return -1;
            }else {
//                return 0;
                // 二级排序： 先按照价格排序，，然后按照 商品名称排序 从低到高
                // 就是在排序里面进行排序
                return this.name.compareTo(goods.name);
                // 二级排序： 先按照价格排序，，然后按照 商品名称排序 从高到低
//                return -this.name.compareTo(goods.name);
            }
            //方式二：其实就是Double里面 也重写了CompareTo的方法
//            return Double.compare(this.price,goods.price);
        }
        throw new RuntimeException("商品类型不一样");
    }
}

Comparable 与 Comparator 的使用对比：
Comparable： 让类去实现Comparable 接口的方式，一旦使用，能确保实现Comparable类的对象在哪里都能比较。

Comparator： 在相比较大小的地方创建一个Comparator的对象，然后就在这个位置进行比较。（一次性的）

---