java中的xxxable和xxxator使用及说明_Java

前言

相信有一定工作经验的朋友，都见过或者用过xxxable和xxxator ，比如常见的comparable和comparator，还有还有常见并且容易迷糊的iterable和iterator，看这名字，前两个是和比较相关的，后两个是和迭代相关. 但是命名如此相似的接口，又有何区别呢?各自的用途又是什么呢? 今天阿亮带大家一起揭开这神秘的面纱.

揭秘

首先我们要明确的是，xxxable和xxxator都是接口，都是用来描述其子类具有某种能力的. 因为在java中，接口就是用来定义能力的. 接口中的方法，就代表着其实现类有什么能力. 因为实现类必须要实现接口中的所有方法.

从名称上感受

首先，直观的从名称上直观的感受，复习一下英文

–able: 表形容词，可…的，能…

able单词

所以，今天我们要研究的其中两个主角，

comparable: 可比较的iterable: 可迭代的
-ator: 表名词，通常由ate结尾的动词而来，做事的人或物

ator结尾单词

所以，我们今天要研究的另外两个主角

comparator: 比较器
iterator: 迭代器

一番咬文嚼字，从字面上理解：

xxxable 就是具有xxx能力，是形容词，带入java接口，就这么认为: 实现了xxxable接口，代表着具有了xxx能力，可以进行xxx. 着重描述的是: 实现类具有xxx能力.

xxxator 就是xxx器，是名词，带入java中的接口，就可以这么认为: 实现了xxxator接口，就代表着可以干xx. 着重描述的是: 实现类可以对某个对象进行xxx.

看到这儿，可能还是有点模糊，不用着急，我们从代码，亲自来感受一下，感受完了再回过头来看这段.

从代码带入

上面我们从名称上理解了，下面我们从实操代码入手，直观感受.

comparable接口

位于java.lang 包下，只有一个抽象方法

public int compareto(t o);

实现这个方法，必须实现compareto这个方法，实现类就具有可比较的能力了.

比较肯定要区分大小，那这个方法要怎么区分大小呢? 方法的doc注释上解释了

a negative integer， zero， or a positive integer as this object is less than， equal to， or greater than the specified object.

大意就是返回一个负整数，零或正整数，表示此对象小于，等于或大于指定的对象。

现在我们假设一个场景，我们有一个<书本>对象，有一个序号属性，通过序号的大小，来对书进行比较，一遍排序整理.指定的规则是: 编号小的更大，编号大的更小，

书籍类的声明如下：

public class book implements comparable<book>{

    private int order;
    private string name;

    public book(int order, string name) {
        this.order = order;
        this.name = name;
    }

    public int getorder() {
        return order;
    }

    @override
    public int compareto(book o) {
        //  相等
        if (this == o || this.getorder() == o.getorder()) return 0;
        // 如果 此类的order大于被比较的order,返回-1,表示此书"更小"
        if (this.order > o.getorder()) {
            return -1;
        }
        return 1;
    }

    @override
    public string tostring() {
        return "book{" +
                "order=" + order +
                ", name='" + name + '\'' +
                '}';
    }

怎么使用呢，最简单的是比较两本书

        // 比较两本书
        book songs = new book(1, "诗经");
        book threekingdoms = new book(2, "三国演义");

        int i = songs.compareto(threekingdoms);
        // 返回1, 正数, 代表 诗经 "大于" 三国演义
        system.out.println(i);

感觉这样好像没有什么用. 下面展示一个比较可能会在开发中用到的: 对书籍数组进行排序

        // 对书进行排序
        book[] books = new book[3];
        book songs = new book(1, "诗经");
        book threekingdoms = new book(2, "三国演义");
        book soulland = new book(3, "斗罗大陆");
        books[0] = soulland;
        books[1] = songs;
        books[2] = threekingdoms;
        // 排序之前
        system.out.println(arrays.tostring(books));
        // 利用arrays.sort进行排序 (这个方法是升序)
        arrays.sort(books);
        // 排序之后
        system.out.println(arrays.tostring(books));

输出结果为：

[book{order=3, name='斗罗大陆'}, book{order=1, name='诗经'}, book{order=2, name='三国演义'}]

[book{order=3, name='斗罗大陆'}, book{order=2, name='三国演义'}, book{order=1, name='诗经'}]

因为我们定义是: 编号越大，书籍 “越小”，所以这个结果是没问题. arrays.sort方法就是利用comparable，进行比较然后排序的

如果book这个类不实现java.lang.comparable，然后调用arrays.sort(books);猜猜会怎样?

同理， java集合stream流中的sorted()方法，也是同样的道理. 此处不展开，感兴趣的朋友请移步:

另外，我们知道 java.util.treeset 这个集合，添加进去的元素自动就排序好了，比如我 new treeset<integer> ，然后往里面添加几个数字，打印出来就是有序的，或者new treeset<string>.

    @test
    public void test4(){
        // 数字treeset
        treeset<integer> integers = new treeset<>();
        integers.add(20);
        integers.add(11);
        integers.add(34);
        integers.add(49);
        system.out.println(integers);

        // 字符串treeset
        treeset<string> strings = new treeset<>();
        strings.add("b");
        strings.add("e");
        strings.add("g");
        strings.add("a");
        system.out.println(strings);
    }

输出：

[11, 20, 34, 49]

[a, b, e, g]

我添加顺序是随意的，最终打印出来的结果是有序的，大家有没有想过这个排序规则是怎么定义的能?在哪里定义的呢?

相信大家已经猜到了，其实就是integer string已经实现了java.lang.comparable接口， treeset才知道他们的比较规则，然后由此来进行排序. 如果你往treeset中添加一个没有实现comparable接口的元素，看看会出现什么情况.

当然，treeset还有另一种指定规则的方式，我们下面讨论java.util.comparator的时候再说

comparator 接口

说完了comparable，然后我们来说说comparator

comparator 位于java.util包下，可以翻译为比较器，是一个函数式接口，其中只有一个抽象方法

int compare(t o1， t o2);

实现这个方法之后，就可以对两个对象进行比较了. 因为comparator是比较器，是工具，所以可以用这个工具来对两个对象进行比较

比较的规则也是类似，如果compare方法返回了了一个正数 0 负数，则说明 o1 大于等于小于 o2

上代码，还是以上面的书籍为例，但是不再实现comparable接口

书籍类：

public class book {

    private int order;
    private string name;

    public book(int order, string name) {
        this.order = order;
        this.name = name;
    }

    public int getorder() {
        return order;
    }


    @override
    public string tostring() {
        return "book{" +
                "order=" + order +
                ", name='" + name + '\'' +
                '}';
    }

}

然后我们再为书籍建一个比较器，书籍比较器

public class bookcomparator implements comparator<book> {   
    
    @override
    public int compare(book o1, book o2) {
        if (o1 == o2 || o1.getorder() == o2.getorder()) return 0;
        
        if (o1.getorder() > o2.getorder()) {
            return -1;
        }
        return 1;
    }
    
}

我们还是先比较两本书，但是此时book已经没有实现comparable接口，没有compareto方法，所以不能直接比较，需要使用书籍比较器进行比较

        // 比较两本书
        book songs = new book(1, "诗经");
        book threekingdoms = new book(2, "三国演义");

        // 使用书籍比较器进行比较
        bookcomparator bookcomparator = new bookcomparator();
        int i = bookcomparator.compare(songs, threekingdoms);
        // 返回1, 正数, 代表 诗经 "大于" 三国演义
        system.out.println(i);

再来排序，

        // 对书进行排序
        book[] books = new book[3];
        book songs = new book(1, "诗经");
        book threekingdoms = new book(2, "三国演义");
        book soulland = new book(3, "斗罗大陆");
        books[0] = soulland;
        books[1] = songs;
        books[2] = threekingdoms;
        // 排序之前
        system.out.println(arrays.tostring(books));
        // 利用arrays.sort进行排序,因为此时book没有实现comparable接口,直接使用下面的方法是没办法进行排序的
        // arrays.sort(books);
        // 利用 书籍比较器进行排序
        bookcomparator bookcomparator = new bookcomparator();
        arrays.sort(books,bookcomparator);
        // 排序之后
        system.out.println(arrays.tostring(books));

结果：

[book{order=3, name='斗罗大陆'}, book{order=1, name='诗经'}, book{order=2, name='三国演义'}]

[book{order=3, name='斗罗大陆'}, book{order=2, name='三国演义'}, book{order=1, name='诗经'}]

比较器毕竟是工具，所以工具还提供了一些额外的方法比如reversed

上面的排序，我看着不太舒服，我想倒序一下，当然比较器已经固定了，就不能再改了

在排序时，可以这样

arrays.sort(books，bookcomparator.reversed());

排序后的结果就是:

[book{order=1， name='诗经'}， book{order=2， name='三国演义'}， book{order=3， name='斗罗大陆'}]

同理， java集合stream流中除了sorted()方法，还提供了一个重载方法 sorted(comparator<? super t> comparator) 也是同样的道理.传入一个比较器进行比较，此处不展开，感兴趣的朋友请移步:

上面在讲treeset时，我们还留了一个悬念， treeset 可以通过另外一种方式指定排序规则，那肯定是用比较器来指定规则啦

首先我们使用前面的方式(注意:此时book未实现comparable接口)

        // 我们先来试试之前我用的方法
        treeset<book> books = new treeset<>();
        books.add(new book(1, "诗经"));
        books.add(new book(3, "斗罗大陆"));
        books.add(new book(2, "三国演义"));
        system.out.println(books);

肯定会出问题的，因为此时treeset已经不知道用什么规则对添加进来的元素排序了，此时应该使用另一种方式

        // new 书籍比较器
        bookcomparator bookcomparator = new bookcomparator();
        // 构造treeset时将比较器传入
        treeset<book> books = new treeset<>(bookcomparator);
        books.add(new book(1, "诗经"));
        books.add(new book(3, "斗罗大陆"));
        books.add(new book(2, "三国演义"));
        system.out.println(books);

结果也是一样正确的被排序好的.

这里多提一嘴，因为comparator是个函数式接口，更多时候我们使用的匿名内部类或者lambda来实现一个构造器，而不是单独的创建一个书籍比较器，除非这个比较器需要在不止一个地方使用，此处不展开描述.

好了到此为此，我们已经搞清楚了comparable和comparator的用法