比較Java中的Comparable排序接口和Comparator比擬器接口。本站提示廣大學習愛好者：（比較Java中的Comparable排序接口和Comparator比擬器接口）文章只能為提供參考，不一定能成為您想要的結果。以下是比較Java中的Comparable排序接口和Comparator比擬器接口正文
Comparable
Comparable 是排序接口。
若一個類完成了Comparable接口，就意味著“該類支撐排序”。 即然完成Comparable接口的類支撐排序，假定如今存在“完成Comparable接口的類的對象的List列表(或數組)”，則該List列表(或數組)可以經由過程 Collections.sort（或 Arrays.sort）停止排序。
另外，“完成Comparable接口的類的對象”可以用作“有序映照(如TreeMap)”中的鍵或“有序聚集(TreeSet)”中的元素，而不須要指定比擬器。
Comparable 接口僅僅只包含一個函數，它的界說以下：
package java.lang;
import java.util.*;
public interface Comparable<T> {
public int compareTo(T o);
}
解釋： 假定我們經由過程 x.compareTo(y) 來“比擬x和y的年夜小”。若前往“正數”，意味著“x比y小”；前往“零”，意味著“x等於y”；前往“負數”，意味著“x年夜於y”。
Comparable 接口曾經泛型化了，所以完成 Comparable 的對象聲明它可以與甚麼類型停止比擬。（平日，這是對象自己的類型，然則有時也能夠是父類。）
public interface Comparable { public boolean compareTo(T other); }
所以 Comparable 接口包括一個類型參數 T，該參數是一個完成 Comparable 的類可以與之比擬的對象的類型。這意味著假如界說一個完成 Comparable 的類，好比 String，就必需不只聲明類支撐比擬，還要聲明它可與甚麼比擬（平日是與它自己比擬）：
public class String implements Comparable { ... }
如今來斟酌一個二元 max() 辦法的完成。您想要接收兩個雷同類型的參數，兩者都是 Comparable，而且互相之間是 Comparable。榮幸的是，假如應用泛型辦法和無限制類型參數的話，這相當直不雅：
public static > T max(T t1, T t2) { if (t1.compareTo(t2) > 0) return t1; else return t2; }
在本例中，您界說了一個泛型辦法，在類型 T 上泛型化，您束縛該類型擴大（完成） Comparable。兩個參數都必需是 T 類型，這表現它們是雷同類型，支撐比擬，而且互相可比擬。輕易！
更好的是，編譯器將應用類型推理來肯定當挪用 max() 時 T 的值表現甚麼意思。所以基本不消指定 T，上面的挪用就可以任務：
String s = max("moo", "bark");
編譯器將盤算出 T 的預定值是 String，是以它將停止編譯和類型檢討。然則假如您試圖用不完成 Comparable 的 類 X 的參數挪用max()，那末編譯器將不許可如許做。
Comparator
Comparator 是比擬器接口。
我們若須要掌握某個類的順序，而該類自己不支撐排序(即沒有完成Comparable接口)；那末，我們可以樹立一個“該類的比擬器”來停止排序。這個“比擬器”只須要完成Comparator接口便可。
也就是說，我們可以經由過程“完成Comparator類來新建一個比擬器”，然後經由過程該比擬器對類停止排序。
Comparator 接口僅僅只包含兩個個函數，它的界說以下：
package java.util;
public interface Comparator<T> {
int compare(T o1, T o2);
boolean equals(Object obj);
}
解釋：
1.若一個類要完成Comparator接口：它必定要完成compareTo(T o1, T o2) 函數，但可以不完成 equals(Object obj) 函數。
為何可以不完成 equals(Object obj) 函數呢？ 由於任何類，默許都是曾經完成了equals(Object obj)的。 Java中的一切類都是繼續於java.lang.Object，在Object.java中完成了equals(Object obj)函數；所以，其它一切的類也相當於都完成了該函數。
2.int compare(T o1, T o2) 是“比擬o1和o2的年夜小”。前往“正數”，意味著“o1比o2小”；前往“零”，意味著“o1等於o2”；前往“負數”，意味著“o1年夜於o2”。
Comparator 和 Comparable 比擬
Comparable是排序接口；若一個類完成了Comparable接口，就意味著“該類支撐排序”。
而Comparator是比擬器；我們若須要掌握某個類的順序，可以樹立一個“該類的比擬器”來停止排序。
我們不難發明：Comparable相當於“外部比擬器”，而Comparator相當於“內部比擬器”。
我們經由過程一個測試法式來對這兩個接口停止解釋。源碼以下：
import java.util.*;
import java.lang.Comparable;
/**
* @desc "Comparator"和“Comparable”的比擬法式。
* (01) "Comparable"
* 它是一個排序接口，只包括一個函數compareTo()。
* 一個類完成了Comparable接口，就意味著“該類自己支撐排序”，它可以直接經由過程Arrays.sort() 或 Collections.sort()停止排序。
* (02) "Comparator"
* 它是一個比擬器接口，包含兩個函數：compare() 和 equals()。
* 一個類完成了Comparator接口，那末它就是一個“比擬器”。其它的類，可以依據該比擬器去排序。
*
* 綜上所述：Comparable是外部比擬器，而Comparator是內部比擬器。
* 一個類自己完成了Comparable比擬器，就意味著它自己支撐排序；若它自己沒完成Comparable，也能夠經由過程內部比擬器Comparator停止排序。
*/
public class CompareComparatorAndComparableTest{
public static void main(String[] args) {
// 新建ArrayList(靜態數組)
ArrayList<Person> list = new ArrayList<Person>();
// 添加對象到ArrayList中
list.add(new Person("ccc", 20));
list.add(new Person("AAA", 30));
list.add(new Person("bbb", 10));
list.add(new Person("ddd", 40));
// 打印list的原始序列
System.out.printf("Original sort, list:%s\n", list);
// 對list停止排序
// 這裡會依據“Person完成的Comparable<String>接口”停止排序，即會依據“name”停止排序
Collections.sort(list);
System.out.printf("Name sort, list:%s\n", list);
// 經由過程“比擬器(AscAgeComparator)”，對list停止排序
// AscAgeComparator的排序方法是：依據“age”的升序排序
Collections.sort(list, new AscAgeComparator());
System.out.printf("Asc(age) sort, list:%s\n", list);
// 經由過程“比擬器(DescAgeComparator)”，對list停止排序
// DescAgeComparator的排序方法是：依據“age”的降序排序
Collections.sort(list, new DescAgeComparator());
System.out.printf("Desc(age) sort, list:%s\n", list);
// 斷定兩個person能否相等
testEquals();
}
/**
* @desc 測試兩個Person比擬能否相等。
* 因為Person完成了equals()函數：若兩person的age、name都相等，則以為這兩個person相等。
* 所以，這裡的p1和p2相等。
*
* TODO：若去失落Person中的equals()函數，則p1不等於p2
*/
private static void testEquals() {
Person p1 = new Person("eee", 100);
Person p2 = new Person("eee", 100);
if (p1.equals(p2)) {
System.out.printf("%s EQUAL %s\n", p1, p2);
} else {
System.out.printf("%s NOT EQUAL %s\n", p1, p2);
}
}
/**
* @desc Person類。
* Person完成了Comparable接口，這意味著Person自己支撐排序
*/
private static class Person implements Comparable<Person>{
int age;
String name;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public String toString() {
return name + " - " +age;
}
/**
* 比擬兩個Person能否相等：若它們的name和age都相等，則以為它們相等
*/
boolean equals(Person person) {
if (this.age == person.age && this.name == person.name)
return true;
return false;
}
/**
* @desc 完成 “Comparable<String>” 的接口，即重寫compareTo<T t>函數。
* 這裡是經由過程“person的名字”停止比擬的
*/
@Override
public int compareTo(Person person) {
return name.compareTo(person.name);
//return this.name - person.name;
}
}
/**
* @desc AscAgeComparator比擬器
* 它是“Person的age的升序比擬器”
*/
private static class AscAgeComparator implements Comparator<Person> {
@Override
public int compare(Person p1, Person p2) {
return p1.getAge() - p2.getAge();
}
}
/**
* @desc DescAgeComparator比擬器
* 它是“Person的age的升序比擬器”
*/
private static class DescAgeComparator implements Comparator<Person> {
@Override
public int compare(Person p1, Person p2) {
return p2.getAge() - p1.getAge();
}
}
}
上面對這個法式停止解釋。
1.Person類界說。以下：
private static class Person implements Comparable<Person>{
int age;
String name;
...
/**
* @desc 完成 “Comparable<String>” 的接口，即重寫compareTo<T t>函數。
* 這裡是經由過程“person的名字”停止比擬的
*/
@Override
public int compareTo(Person person) {
return name.compareTo(person.name);
//return this.name - person.name;
}
}
解釋：
(1) Person類代表一小我，Persong類中有兩個屬性：age(年事) 和 name“人名”。
(2) Person類完成了Comparable接口，是以它能被排序。
2.在main()中，我們創立了Person的List數組(list)。以下：
// 新建ArrayList(靜態數組)
ArrayList<Person> list = new ArrayList<Person>();
// 添加對象到ArrayList中
list.add(new Person("ccc", 20));
list.add(new Person("AAA", 30));
list.add(new Person("bbb", 10));
list.add(new Person("ddd", 40));
3.接著，我們打印出list的全體元素。以下：
// 打印list的原始序列
System.out.printf("Original sort, list:%s\n", list);
4.然後，我們經由過程Collections的sort()函數，對list停止排序。
因為Person完成了Comparable接口，是以經由過程sort()排序時，會依據Person支撐的排序方法，即 compareTo(Person person) 所界說的規矩停止排序。以下：
// 對list停止排序
// 這裡會依據“Person完成的Comparable<String>接口”停止排序，即會依據“name”停止排序
Collections.sort(list);
System.out.printf("Name sort, list:%s\n", list);
5.比較Comparable和Comparator
我們界說了兩個比擬器 AscAgeComparator 和 DescAgeComparator，來分離對Person停止 升序 和 下降 排序。
6.AscAgeComparator比擬器
它是將Person依照age停止升序排序。代碼以下：
/**
* @desc AscAgeComparator比擬器
* 它是“Person的age的升序比擬器”
*/
private static class AscAgeComparator implements Comparator<Person> {
@Override
public int compare(Person p1, Person p2) {
return p1.getAge() - p2.getAge();
}
}
7.DescAgeComparator比擬器
它是將Person依照age停止降序排序。代碼以下：
/**
* @desc DescAgeComparator比擬器
* 它是“Person的age的升序比擬器”
*/
private static class DescAgeComparator implements Comparator<Person> {
@Override
public int compare(Person p1, Person p2) {
return p2.getAge() - p1.getAge();
}
}
8.運轉成果 運轉法式，輸入以下：
Original sort, list:[ccc - 20, AAA - 30, bbb - 10, ddd - 40] Name sort, list:[AAA - 30, bbb - 10, ccc - 20, ddd - 40] Asc(age) sort, list:[bbb - 10, ccc - 20, AAA - 30, ddd - 40] Desc(age) sort, list:[ddd - 40, AAA - 30, ccc - 20, bbb - 10] eee - 100 EQUAL eee - 100
