Java-Comparable接口与Comparator接口的使用

Comparable接口的使用

1 像String，包装类等等已经实现了Comparable接口的，可以直接使用api中的方法排序，且排序规则默认为升序。若是自定义数据类型排序，则参与排序类对象所属的类应实现Comparable接口，并重写其中的compareTo(obj) 方法

2 重写compareTo(obj) 的规则：

• 如果当前对象this大于形参对象0bj，则返回正整数，
• 如果当前对象this小于形参对象0bj，则返回负整教，
• 如果当前对象this等于形参对象0bj，则返回零。

public class Goods implements Comparable {
    private String name;
    private int price;

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

    // 省略Getter、Setter、toString方法

    @Override
    public int compareTo(Object o) {
        // 先按商品名升序排序，再按价格降序排序
        if (o instanceof Goods) {
            Goods good = (Goods) o;
            if (this.getName().equals(good.getName())){
                return Integer.compare(good.getPrice(), this.getPrice());
            } else {
                return this.getName().compareTo(good.getName());
            }
        }

        throw new RuntimeException("传入的参数与要求的类型不匹配");
    }
}
// ---------------或-----------------------------
public class Goods implements Comparable<Goods> {
    private String name;
    private int price;

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

    // 省略Getter、Setter、toString方法

    @Override
    public int compareTo(Goods o) {
        // 先按商品名升序排序，再按价格降序排序
        if (this.getName().equals(o.getName())){
            return Integer.compare(o.getPrice(), this.getPrice());
        } else {
            return this.getName().compareTo(o.getName());
        }
    }
}

public class ComparableTest {
    public static void main(String[] args) {
        // 1 已经实现Comparable接口的数据类型排序
        String[] strs = new String[]{"jack", "lisa", "michael", "tom", "jason", "lucy", "nancy"};
        Arrays.sort(strs);
        System.out.println(Arrays.toString(strs));

        // 2 自定义数据类型排序
        Goods[] goods = new Goods[5];
        goods[0] = new Goods("pencle", 50);
        goods[1] = new Goods("apple", 1000);
        goods[2] = new Goods("book", 800);
        goods[3] = new Goods("computer", 5000);
        goods[4] = new Goods("book", 50);
        Arrays.sort(goods);
        System.out.println(Arrays.toString(goods));
    }
}

Comparator接口的使用

1 当元素的类型没有实现java.Lang.Comparable接口而又不方便修代码，或者实现了java.Lang.Comparable接口的排序规则不适合当前的操作，那么可以考虑使用 Comparator 的对象来排字

2 重写compare（Object o1，Object o2）方法，比较o1和o2的大小：

• 如果方法返回正整数，则表示o1大于o2；
• 如果返回0，表示相等；
• 返回负整数，表示o1小于o2。

public class Goods {
    private String name;
    private int price;

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

    // 省略Getter、Setter、toString方法
}

public class ComparatorTest {
    public static void main(String[] args) {
        // 1 已经实现Comparable接口的数据类型排序
        String[] strs = new String[]{"jack", "lisa", "michael", "tom", "jason", "lucy", "nancy"};
        Arrays.sort(strs, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                // 升序
                // return o1.compareTo(o2);
                // 降序。return o2.compareTo(o1);
                return -o1.compareTo(o2);
            }
        });
        System.out.println(Arrays.toString(strs));

        // 2 自定义数据类型排序
        Goods[] goods = new Goods[5];
        goods[0] = new Goods("pencle", 50);
        goods[1] = new Goods("apple", 1000);
        goods[2] = new Goods("orange", 800);
        goods[3] = new Goods("computer", 5000);
        goods[4] = new Goods("book", 50);
        Arrays.sort(goods, new Comparator<Goods>() {
            @Override
            public int compare(Goods o1, Goods o2) {
                // 先按价格升序排序，再按商品名升序排序
                if (o1.getPrice() == o2.getPrice()) {
                    return o1.getName().compareTo(o2.getName());
                } else {
                    return o1.getPrice() > o2.getPrice() ? 1 : -1;
                }
            }
        });
        System.out.println(Arrays.toString(goods));
    }
}

Comparable接口与Comparator的使用的对比

• Comparable接口

  参与比较对象所属的类需要实现此接口，且实现之后，保证Comparable接口实现类的对象在在何位置都可以比较大小。

• Comparator接口

  哪里用到哪里实现此接口，属于临时性的比较，适用于不能直接修改源码的类，因为不能修改源码就意味着不能让其实现Comparable接口，只能使用Comparator。