C/C++教程

可能是最简单最通透的Comparable和Comparator接口返回值理解

本文主要是介绍可能是最简单最通透的Comparable和Comparator接口返回值理解,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

先说 Comparator 接口,这个理解了,下一个就理解了

一、Comparator 的用法(暂不考虑0,因为0不处理)

返回-1,1交换不交换位置,如果撇开比较器的两个参数和jdk默认顺序来说,存粹是错误的

接口如下:原文链接

public interface Comparator<T> {

    int compare(T o1, T o2);
}

现提出如下标准:

  • 标准1:jdk 默认要升序排列,即程序排序规则是 asc ,升序排列
  • 标准2:Comparator 接口第一个参数 o1 是第二个参数 o2 后面的对象

基于这 2 个标准,假设:

  • 1 = true
  • -1 = false

重点来了,有以下两种情况和处理方式:

  • 情况1:后面的比前面大,即 o1 > o2 ,是 标准1中的 升序 吗?是,返回 true,不交换前后位置。
  • 情况2:后面的比前面小,即 o1 < o2 ,是 标准1中的 升序 吗?不是,返回 false, 交换前后位置。

问:为什么第二种降序要交换前后位置?
答:因为 标准1 ,默认要对数组进行升序排列,如果发现降序的序列,自然要交换位置

扩散问题1:如果我想按降序排列呢?
答:那你就在升序时候返回 false,降序时候返回 true 就行

扩散问题2:如果我不比较,直接返回1或者-1呢?
答:因为标准1,返回1(true)代表都是升序,自然不必交换,返回-1(false)代表都不是升序,都要交换,即数组反转

总结:

想要升序排列,如果比较器2个参数是升序排列,就返回true,否则返回false即可
想要降序排列,如果比较器2个参数是降序排列,就返回true,否则返回false即可

附测试代码:

public class ComparatorDemo {

    private final int local;

    public ComparatorDemo(int local) {
        this.local = local;
    }

    @Override
    public String toString() {
        return "" + local;
    }

    public static void main(String[] args) {
        List<ComparatorDemo> asc = new ArrayList<>();

        asc.add(new ComparatorDemo(13));
        asc.add(new ComparatorDemo(3));
        asc.add(new ComparatorDemo(15));
        asc.add(new ComparatorDemo(18));

        // 我想升序排列
        asc.sort((second,first) -> {
            if(second.local > first.local){
                return 1; //是升序,返回true
            }else if(second.local < first.local){
                return -1; //是降序,返回false
            }else {
                return 0;
            }
        });

        System.out.print("升序数组:");
        System.out.println(asc);

        List<ComparatorDemo> desc = new ArrayList<>();

        desc.add(new ComparatorDemo(13));
        desc.add(new ComparatorDemo(3));
        desc.add(new ComparatorDemo(15));
        desc.add(new ComparatorDemo(18));

        // 我想降序排列
        desc.sort((o1,o2) -> {
            if(o1.local > o2.local){
                return -1; //不是降序,返回false
            }else if(o1.local < o2.local){
                return 1; //是降序,返回true
            }else {
                return 0;
            }
        });

        System.out.print("降序数组:");
        System.out.println(desc);
    }

}

二、Comparable 的用法(暂不考虑0,因为0不处理)

规则和 Comparator 一样,只需把当前 Comparable 实例当成Comparator#compare(T o1, T o2)第一个参数即可

测试代码:

public class ComparableImpl implements Comparable<ComparableImpl> {

    private final Integer local;

    public ComparableImpl(Integer num) {
        this.local = num;
    }

    @Override
    public String toString() {
        return "" + local;
    }

    @Override
    public int compareTo(ComparableImpl before) {
        if (local > before.local) {
            return 1; //是升序
        } else if (local < before.local) {
            return -1; //是降序
        }
        return 0;
    }

    public static void main(String[] args) {
        ComparableImpl[] ables = new ComparableImpl[]{
                new ComparableImpl(1),
                new ComparableImpl(13),
                new ComparableImpl(25),
                new ComparableImpl(4),
        };

        Arrays.sort(ables);

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

}
这篇关于可能是最简单最通透的Comparable和Comparator接口返回值理解的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!