关于后端:Java-中-Comparable-和-Comparator-的区别

1次阅读

共计 2370 个字符，预计需要花费 6 分钟才能阅读完成。

聪明人有一个特点，就是长于把无价值的事做得绘声绘色，在玻璃鱼缸里游泳，也有乘风破浪的魄力。

Java 中为咱们提供了两种比拟机制：Comparable 和 Comparator，二者都是用来实现对象的比拟、排序。

上面别离对 Comparable 和 Comparator 做具体介绍并总结。

Comparable 能够认为是一个内比拟器，实现了 Comparable 接口的类有一个特点，就是这些类是能够和本人比拟的，至于具体和另一个实现了 Comparable 接口的类如何比拟，则依赖 compareTo 办法的实现。

如果 add 进入一个 Collection 的对象想要 Collections 的 sort 办法帮你主动进行排序的话，那么这个对象必须实现 Comparable 接口。compareTo 办法的返回值是 int，有三种状况：

比拟者大于被比拟者，返回正整数

比拟者等于被比拟者，返回 0

比拟者小于被比拟者，返回负整数

写个很简略的例子：

public class Domain implements Comparable<Domain> {
    private String str;

    public Domain(String str) {this.str = str;}

    public int compareTo(Domain domain) {if (this.str.compareTo(domain.str) > 0)
            return 1;
        else if (this.str.compareTo(domain.str) == 0)
            return 0;
        else
            return -1;
    }

    public String getStr() {return str;}
}

public static void main(String[] args) {Domain d1 = new Domain("c");
    Domain d2 = new Domain("c");
    Domain d3 = new Domain("b");
    Domain d4 = new Domain("d");
    System.out.println(d1.compareTo(d2));
    System.out.println(d1.compareTo(d3));
    System.out.println(d1.compareTo(d4));
}

运行后果为：

0
1
-1

留神一下，后面说实现 Comparable 接口的类是能够反对和本人比拟的，然而其实代码外面 Comparable 的泛型未必就肯定要是 Domain，将泛型指定为 String 或者指定为其余任何任何类型都能够，只有开发者指定了具体的比拟算法就行。

Comparator 接口外面有一个 compare 办法，办法有两个参数 T o1 和 T o2，是泛型的示意形式，别离示意待比拟的两个对象，办法返回值和 Comparable 接口一样是 int，有三种状况：

o1 大于 o2，返回正整数

o1 等于 o2，返回 0

o1 小于 o3，返回负整数

写个很简略的例子：

public class DomainComparator implements Comparator<Domain> {public int compare(Domain domain1, Domain domain2) {if (domain1.getStr().compareTo(domain2.getStr()) > 0)
            return 1;
        else if (domain1.getStr().compareTo(domain2.getStr()) == 0)
            return 0;
        else
            return -1;
    }
}

public static void main(String[] args) {Domain d1 = new Domain("c");
    Domain d2 = new Domain("c");
    Domain d3 = new Domain("b");
    Domain d4 = new Domain("d");
    DomainComparator dc = new DomainComparator();
    System.out.println(dc.compare(d1, d2));
    System.out.println(dc.compare(d1, d3));
    System.out.println(dc.compare(d1, d4));
}

看一下运行后果：

0
1
-1

因为泛型指定死了，所以实现 Comparator 接口的实现类只能是两个雷同的对象（不能一个 Domain、一个 String）进行比拟了，实现 Comparator 接口的实现类个别都会以 ” 待比拟的实体类 +Comparator” 来命名

如果实现类没有实现 Comparable 接口，又想对两个类进行比拟（或者实现类实现了 Comparable 接口，然而对 compareTo 办法内的比拟算法不称心），那么能够实现 Comparator 接口，自定义一个比拟器，写比拟算法。

实现 Comparable 接口的形式比实现 Comparator 接口的耦合性要强一些，如果要批改比拟算法，要批改 Comparable 接口的实现类，而实现 Comparator 的类是在内部进行比拟的，不须要对实现类有任何批改。因而：

对于一些一般的数据类型（比方 String, Integer, Double…），它们默认实现了 Comparable 接口，实现了 compareTo 办法，咱们能够间接应用。

而对于一些自定义类，它们可能在不同状况下须要实现不同的比拟策略，咱们能够新创建 Comparator 接口，而后应用特定的 Comparator 实现进行比拟。

不同之处：

个人感觉说出上文观点，这个发问就算答复完了，如果非要说不同之处，那就是：