日期：2017/11/19
接口 Comparable<T> 与 接口 Comparator<T> 的区别
一、接口 Comparable<T>
java.lang
接口 Comparable<T>
-
类型参数：
-
T- 可以与此对象进行比较的那些对象的类型
-
所有已知子接口：
- Delayed, Name, RunnableScheduledFuture<V>, ScheduledFuture<V>
-
所有已知实现类：
- Authenticator.RequestorType, BigDecimal, BigInteger, Boolean, Byte, ByteBuffer, Calendar, Character, CharBuffer, Charset, ClientInfoStatus, CollationKey, Component.BaselineResizeBehavior, CompositeName, CompoundName, Date, Date, Desktop.Action, Diagnostic.Kind, Dialog.ModalExclusionType, Dialog.ModalityType, Double, DoubleBuffer, DropMode, ElementKind, ElementType, Enum, File, Float, FloatBuffer, Formatter.BigDecimalLayoutForm, FormSubmitEvent.MethodType, GregorianCalendar, GroupLayout.Alignment, IntBuffer, Integer, JavaFileObject.Kind, JTable.PrintMode, KeyRep.Type, LayoutStyle.ComponentPlacement, LdapName, Long, LongBuffer, MappedByteBuffer, MemoryType, MessageContext.Scope, Modifier, MultipleGradientPaint.ColorSpaceType, MultipleGradientPaint.CycleMethod, NestingKind, Normalizer.Form, ObjectName, ObjectStreamField, Proxy.Type, Rdn, Resource.AuthenticationType, RetentionPolicy, RoundingMode, RowFilter.ComparisonType, RowIdLifetime, RowSorterEvent.Type, Service.Mode, Short, ShortBuffer, SOAPBinding.ParameterStyle, SOAPBinding.Style, SOAPBinding.Use, SortOrder, SourceVersion, SSLEngineResult.HandshakeStatus, SSLEngineResult.Status, StandardLocation, String, SwingWorker.StateValue, Thread.State, Time, Timestamp, TimeUnit, TrayIcon.MessageType, TypeKind, URI, UUID, WebParam.Mode, XmlAccessOrder, XmlAccessType, XmlNsForm
public interface Comparable<T>
此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的 compareTo 方法被称为它的自然比较方法。
实现此接口的对象列表（和数组）可以通过 Collections.sort（和 Arrays.sort）进行自动排序。实现此接口的对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。
对于类 C 的每一个 e1 和 e2 来说，当且仅当 e1.compareTo(e2) == 0 与 e1.equals(e2) 具有相同的 boolean 值时，类 C的自然排序才叫做与 equals 一致。注意，null 不是任何类的实例，即使 e.equals(null) 返回 false，e.compareTo(null) 也将抛出 NullPointerException。
建议（虽然不是必需的）最好使自然排序与 equals 一致。这是因为在使用自然排序与 equals 不一致的元素（或键）时，没有显式比较器的有序集合（和有序映射表）行为表现“怪异”。尤其是，这样的有序集合（或有序映射表）违背了根据 equals 方法定义的集合（或映射表）的常规协定。
例如，如果将两个键 a 和 b 添加到没有使用显式比较器的有序集合中，使 (!a.equals(b) && a.compareTo(b) == 0)，那么第二个 add 操作将返回 false（有序集合的大小没有增加），因为从有序集合的角度来看，a 和 b 是相等的。
实际上，所有实现 Comparable 的 Java 核心类都具有与 equals 一致的自然排序。java.math.BigDecimal 是个例外，它的自然排序将值相等但精确度不同的 BigDecimal 对象（比如 4.0 和 4.00）视为相等。
从数学上讲，定义给定类 C 上自然排序的关系式 如下：
{(x, y)|x.compareTo(y) <= 0}。
整体排序的
商
是：
{(x, y)|x.compareTo(y) == 0}。
它直接遵循
compareTo
的协定，商是
C
的
等价关系
，自然排序是
C
的
整体排序
。当说到类的自然排序
与 equals 一致
时，是指自然排序的商是由类的
equals(Object)
方法定义的等价关系。
{(x, y)|x.equals(y)}。
此接口是 Java Collections Framework 的成员。
| 方法摘要 | |
|---|---|
int | compareTo(T o) 比较此对象与指定对象的顺序。 |
| 方法详细信息 |
|---|
compareTo
int compareTo(T o)
-
比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数。
实现类必须确保对于所有的 x 和 y 都存在 sgn(x.compareTo(y)) == -sgn(y.compareTo(x)) 的关系。（这意味着如果 y.compareTo(x) 抛出一个异常，则 x.compareTo(y) 也要抛出一个异常。）
实现类还必须确保关系是可传递的：(x.compareTo(y)>0 && y.compareTo(z)>0) 意味着 x.compareTo(z)>0。
最后，实现者必须确保 x.compareTo(y)==0 意味着对于所有的 z，都存在 sgn(x.compareTo(z)) == sgn(y.compareTo(z))。 强烈推荐 (x.compareTo(y)==0) == (x.equals(y)) 这种做法，但并不是 严格要求这样做。一般来说，任何实现 Comparable 接口和违背此条件的类都应该清楚地指出这一事实。推荐如此阐述：“注意：此类具有与 equals 不一致的自然排序。”
在前面的描述中，符号 sgn(expression) 指定 signum 数学函数，该函数根据 expression 的值是负数、零还是正数，分别返回 -1、0 或 1 中的一个值。
-
-
参数：
-
o- 要比较的对象。
返回：
- 负整数、零或正整数，根据此对象是小于、等于还是大于指定对象。 抛出：
-
ClassCastException- 如果指定对象的类型不允许它与此对象进行比较。
-
例子1：
package com.code.CompareInterface.ComparableInterface;
//类型 Person 必须实现继承的抽象方法 Comparable<String>.compareTo（String）
public class Person implements Comparable<Person>{
private String name;
private Integer age;
public Person(){
}
public Person (String name ,Integer age){
this.name = name;
this.age = age;
}
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
public void setAge(Integer age){
this.age = age;
}
public Integer getAge(){
return age;
}
@Override
public int compareTo(Person p) {
//auto 比较age
if(this.age > p.age){
return (this.age - p.age);
}if(this.age < p.age){
return (this.age - p.age);
}
//auto 比较name
if(this.name.compareTo(p.name) > 0){
return 1;
}
if(this.name.compareTo(p.name) < 0){
return -1;
}
return 0;
}
}
package com.code.CompareInterface.ComparableInterface;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.ListIterator;
public class ComparableTest {
public static void main(String [] args){
Person p1 = new Person("AA",19);
Person p2 = new Person("aa",13);
Person p3 = new Person("CC",13);
Person p4 = new Person("DD",14);
//不能实例化类型 List<Person>
List<Person> list = new ArrayList<Person>();
list.add(p1);
list.add(p2);
list.add(p3);
list.add(p4);
ListIterator it = list.listIterator();
System.out.println(list.size());
while(it.hasNext()){
Person s = new Person();
s = (Person) it.next();
System.out.println(s.getName()+ "---"+s.getAge());
}
System.out.println("------------------------");
//回到正题，进行排序
Collections.sort(list);
for(Person p : list){
System.out.println(p.getName()+"---"+p.getAge());
}
}
}
输出结果：
4
AA---19
aa---13
CC---13
DD---14
------------------------
CC---13
aa---13
DD---14
AA---19
解释：（1）从Person.java 重写的compareTo()可以看出先是比较age值大小，再以name的Unicode序号作为排序依据。
二、接口 Comparator<T>
java.util
接口 Comparator<T>
-
类型参数：
-
T- 此 Comparator 可以比较的对象类型
-
所有已知实现类：
- Collator, RuleBasedCollator
public interface Comparator<T>
强行对某个对象 collection 进行整体排序 的比较函数。可以将 Comparator 传递给 sort 方法（如 Collections.sort 或 Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用 Comparator 来控制某些数据结构（如有序 set或有序映射）的顺序，或者为那些没有自然顺序的对象 collection 提供排序。
当且仅当对于一组元素 S 中的每个 e1 和 e2 而言，c.compare(e1, e2)==0 与 e1.equals(e2) 具有相等的布尔值时，Comparator c 强行对 S 进行的排序才叫做与 equals 一致 的排序。
当使用具有与 equals 不一致的强行排序能力的 Comparator 对有序 set（或有序映射）进行排序时，应该小心谨慎。假定一个带显式 Comparator c 的有序 set（或有序映射）与从 set S 中抽取出来的元素（或键）一起使用。如果 c 强行对 S 进行的排序是与 equals 不一致的，那么有序 set（或有序映射）将是行为“怪异的”。尤其是有序 set（或有序映射）将违背根据 equals 所定义的 set（或映射）的常规协定。
例如，假定使用 Comparator c 将满足 (a.equals(b) && c.compare(a, b) != 0) 的两个元素 a 和 b 添加到一个空 TreeSet 中，则第二个 add 操作将返回 true（树 set 的大小将会增加），因为从树 set 的角度来看，a 和 b 是不相等的，即使这与 Set.add 方法的规范相反。
注：通常来说，让 Comparator 也实现 java.io.Serializable 是一个好主意，因为它们在可序列化的数据结构（像 TreeSet、TreeMap）中可用作排序方法。为了成功地序列化数据结构，Comparator（如果已提供）必须实现 Serializable。
在算术上，定义给定 Comparator c 对给定对象 set S 实施强行排序 的关系式 为：
{(x, y) such that c.compare(x, y) <= 0}.
此整体排序的
商 (quotient)
为：
{(x, y) such that c.compare(x, y) == 0}.
它直接遵循
compare
的协定，商是
S
上的
等价关系
，强行排序是
S
上的
整体排序
。当我们说
c
强行对
S
的排序是
与 equals 一致
的时，意思是说排序的商是对象的
equals(Object)
方法所定义的等价关系：
{(x, y) such that x.equals(y)}.
此接口是 Java Collections Framework 的成员。
| 方法摘要 | |
|---|---|
int | compare(T o1, T o2) 比较用来排序的两个参数。 |
boolean | equals(Object obj) 指示某个其他对象是否“等于”此 Comparator。 |
| 方法详细信息 |
|---|
compare
int compare(T o1, T o2)
-
比较用来排序的两个参数。根据第一个参数小于、等于或大于第二个参数分别返回负整数、零或正整数。
在前面的描述中，符号 sgn(expression) 表示 signum 数学函数，根据 expression 的值为负数、0 还是正数，该函数分别返回 -1、0 或 1。
实现程序必须确保对于所有的 x 和 y 而言，都存在 sgn(compare(x, y)) == -sgn(compare(y, x))。（这意味着当且仅当 compare(y, x) 抛出异常时 compare(x, y) 才必须抛出异常。）
实现程序还必须确保关系是可传递的：((compare(x, y)>0) && (compare(y, z)>0)) 意味着 compare(x, z)>0。
最后，实现程序必须确保 compare(x, y)==0 意味着对于所有的 z 而言，都存在 sgn(compare(x, z))==sgn(compare(y, z))。
虽然这种情况很普遍，但并不 严格要求 (compare(x, y)==0) == (x.equals(y))。一般说来，任何违背这个条件的 Comparator 都应该清楚地指出这一事实。推荐的语言是“注意：此 Comparator 强行进行与 equals 不一致的排序。”
-
-
参数：
-
o1- 要比较的第一个对象。 -
o2- 要比较的第二个对象。
返回：
- 根据第一个参数小于、等于或大于第二个参数分别返回负整数、零或正整数。 抛出：
-
ClassCastException- 如果参数的类型不允许此 Comparator 对它们进行比较。
-
equals
boolean equals(Object obj)
-
指示某个其他对象是否“等于”此 Comparator。此方法必须遵守
Object.equals(Object)的常规协定。此外， 仅当 指定的对象也是一个 Comparator，并且强行实施与此 Comparator 相同的排序时，此方法才返回 true。因此，comp1.equals(comp2)意味着对于每个对象引用 o1 和 o2 而言，都存在 sgn(comp1.compare(o1, o2))==sgn(comp2.compare(o1, o2))。注意，不 重写 Object.equals(Object) 方法总是 安全的。然而，在某些情况下，重写此方法可以允许程序确定两个不同的 Comparator 是否强行实施了相同的排序，从而提高性能。
-
-
参数：
-
obj- 要进行比较的引用对象。
返回：
-
仅当指定的对象也是一个 Comparator，并且强行实施与此 Comparator 相同的排序时才返回
true。
另请参见：
-
Object.equals(Object),Object.hashCode()
-
例子2：
package com.code.CompareInterface.Comparator;
import java.util.Comparator;
//类型 Person 必须实现继承的抽象方法 Comparator<Person>.compare（Person, Person）
public class Person implements Comparator<Person>{
private String name;
private Integer age;
public Person(){
}
public Person (String name ,Integer age){
this.name = name;
this.age = age;
}
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
public void setAge(Integer age){
this.age = age;
}
public Integer getAge(){
return age;
}
@Override
public int compare(Person p1, Person p2) {
if(p1.getAge() > p2.getAge()){
return 1;
}else if(p1.getAge() < p2.getAge()){
return -1;
}else{
if(p1.getName().compareTo(p2.getName()) > 0){
return 1;
}else if(p1.getName().compareTo(p2.getName()) > 0){
return -1;
}else{
return 0;
}
}
}
}
package com.code.CompareInterface.Comparator;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.ListIterator;
import com.code.CompareInterface.ComparableInterface.Person;
public class ComparatorTest {
public static void main(String[] args) {
Person p1 = new Person("AA",19);
Person p2 = new Person("aa",13);
Person p3 = new Person("CC",13);
Person p4 = new Person("DD",14);
//不能实例化类型 List<Person>
List<Person> list = new ArrayList<Person>();
list.add(p1);
list.add(p2);
list.add(p3);
list.add(p4);
ListIterator it = list.listIterator();
System.out.println(list.size());
while(it.hasNext()){
Person s = new Person();
s = (Person) it.next();
System.out.println(s.getName()+ "---"+s.getAge());
}
System.out.println("------------------------");
//区别与Compearable接口
Collections.sort(list);
for(Person p : list){
System.out.println(p.getName()+"---"+p.getAge());
}
}
}
输出结果：
4
AA---19
aa---13
CC---13
DD---14
------------------------
CC---13
aa---13
DD---14
AA---19
验证了：使用两种接口达到一样的效果。
三、两者区别
Comparator位于包java.util下，而Comparable位于包java.lang下，Comparable接口将比较代码嵌入自身类中，而后者在一个独立的类中实现比较。 如果类的设计师没有考虑到Compare的问题而没有实现Comparable接口，可以通过 Comparator来实现比较算法进行排序，并且为了使用不同的排序标准做准备，比如：升序、降序。
1万+
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
