【笔记】Java的Comparable和Comparator

发表于 更新于 分类于 阅读次数：

前言

Java的Comparable和Comparator学习笔记

Comparable接口

  • 在定义类时，实现Comparable接口，即可通过compareTo()方法进行比较
  • 返回值等于0表示两个对象相等，返回值小于0表示当前对象小于参数对象，返回值大于0表示当前对象大于参数对象
1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Cls implements Comparable<Cls> {
    @Override
    public int compareTo(Cls o) {
        return 0;
    }
}

class Main {
    public static void main(String[] args) {
        Cls cls1 = new Cls();
        Cls cls2 = new Cls();
        System.out.println(cls1.compareTo(cls2));
    }
}

Comparator接口

  • 自定义比较器

如果比较的类没有实现Comparable接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Cls {}

class ClsComparator implements Comparator<Cls> {
    @Override
    public int compare(Cls o1, Cls o2) {
        return 0;
    }
}

class Main {
    public static void main(String[] args) {
        ClsComparator clsComparator = new ClsComparator();
        Cls cls1 = new Cls();
        Cls cls2 = new Cls();
        System.out.println(clsComparator.compare(cls1, cls2));
    }
}
  • 简写
1
2
3
4
5
6
7
8
9
10
class Cls {}

class Main {
    public static void main(String[] args) {
        Comparator<Cls> clsComparator = (o1, o2) -> 0;
        Cls cls1 = new Cls();
        Cls cls2 = new Cls();
        System.out.println(clsComparator.compare(cls1, cls2));
    }
}

如果比较的类实现了Comparable接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class Cls implements Comparable<Cls> {
    @Override
    public int compareTo(Cls o) {
        return 0;
    }
}

class ClsComparator implements Comparator<Cls> {
    @Override
    public int compare(Cls o1, Cls o2) {
        return o1.compareTo(o2);
    }
}

class Main {
    public static void main(String[] args) {
        ClsComparator clsComparator = new ClsComparator();
        Cls cls1 = new Cls();
        Cls cls2 = new Cls();
        System.out.println(clsComparator.compare(cls1, cls2));
    }
}
  • 简写
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Cls implements Comparable<Cls> {
    @Override
    public int compareTo(Cls o) {
        return 0;
    }
}

class Main {
    public static void main(String[] args) {
        Comparator<Cls> clsComparator = (o1, o2) -> o1.compareTo(o2);
        Cls cls1 = new Cls();
        Cls cls2 = new Cls();
        System.out.println(clsComparator.compare(cls1, cls2));
    }
}

静态方法

通过指定键生成比较器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Cls implements Comparable<Cls> {

    int field;

    @Override
    public int compareTo(Cls o) {
        return this.field - o.field;
    }
}

class Main {
    public static void main(String[] args) {
        Comparator<Cls> comparator = Comparator.comparing((cls) -> cls.field);
        Cls cls1 = new Cls();
        Cls cls2 = new Cls();
        System.out.println(comparator.compare(cls1, cls2));
    }
}

生成正序比较器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Cls implements Comparable<Cls> {
    @Override
    public int compareTo(Cls o) {
        return 0;
    }
}

class Main {
    public static void main(String[] args) {
        Comparator<Cls> comparator = Comparator.naturalOrder();
        Cls cls1 = new Cls();
        Cls cls2 = new Cls();
        System.out.println(comparator.compare(cls1, cls2));
    }
}
生成null放在头部的正序比较器
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Cls implements Comparable<Cls> {
    @Override
    public int compareTo(Cls o) {
        return 0;
    }
}

class Main {
    public static void main(String[] args) {
        Comparator<Cls> comparator = Comparator.nullsFirst();
        Cls cls1 = new Cls();
        Cls cls2 = new Cls();
        System.out.println(comparator.compare(cls1, cls2));
    }
}
生成null放在尾部的正序比较器
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Cls implements Comparable<Cls> {
    @Override
    public int compareTo(Cls o) {
        return 0;
    }
}

class Main {
    public static void main(String[] args) {
        Comparator<Cls> comparator = Comparator.nullsLast();
        Cls cls1 = new Cls();
        Cls cls2 = new Cls();
        System.out.println(comparator.compare(cls1, cls2));
    }
}

生成倒序比较器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Cls implements Comparable<Cls> {
    @Override
    public int compareTo(Cls o) {
        return 0;
    }
}

class Main {
    public static void main(String[] args) {
        Comparator<Cls> comparator = Comparator.reverseOrder();
        Cls cls1 = new Cls();
        Cls cls2 = new Cls();
        System.out.println(comparator.compare(cls1, cls2));
    }
}

实例方法

倒序排序

1
clsComparator.reversed(cls1, cls2)

多级比较规则

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
class Cls implements Comparable<Cls> {

    int field;

    @Override
    public int compareTo(Cls o) {
        return this.field - o.field;
    }
}

class ClsComparator implements Comparator<Cls> {
    @Override
    public int compare(Cls o1, Cls o2) {
        return 0;
    }
}

class Main {
    public static void main(String[] args) {
        ClsComparator clsComparator = new ClsComparator();
        Cls cls1 = new Cls();
        Cls cls2 = new Cls();
        System.out.println(clsComparator.thenComparing((o1, o2) -> o1.compareTo(o2)).compare(cls1, cls2));
    }
}
  • 简写
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
class Cls implements Comparable<Cls> {

    int field;

    @Override
    public int compareTo(Cls o) {
        return this.field - o.field;
    }
}

class ClsComparator implements Comparator<Cls> {
    @Override
    public int compare(Cls o1, Cls o2) {
        return 0;
    }
}

class Main {
    public static void main(String[] args) {
        ClsComparator clsComparator = new ClsComparator();
        Cls cls1 = new Cls();
        Cls cls2 = new Cls();
        System.out.println(clsComparator.thenComparing((o) -> o.field).compare(cls1, cls2));
    }
}

完成