版本
JDK8(JDK1.8)
Comparable接口重点
-
Comparable是一个函数式接口,里面只有一个compareTo(T o)方法,实现Comparable接口的类意味着是可比较的类
-
Comparable接口和Comparator接口非常容易混淆,Comparator接口虽然也是一个函数式接口其虚方法为compare(T o1, T o2) 这个方法和compareTo(T o) 调用方式有明显不同,所以还是很好区分的,Comparator接口里面还定义了很多静态方法和默认方法
-
compareTo方法意义,x.compareTo(y) > 0相当于x - y > 0
Comparator接口源码可以看我这篇位置 Comparator
Comparable源码
package java.lang;
import java.util.*;
/**
* This interface imposes a total ordering on the objects of each class that
* implements it. This ordering is referred to as the class's <i>natural
* ordering</i>, and the class's {@code compareTo} method is referred to as
* its <i>natural comparison method</i>.<p>
* 此接口对实现它的每个类的对象施加总顺序。
* 这种排序称为类的自然排序,类的compareTo方法称为其自然比较方法
*
*
*
* Lists (and arrays) of objects that implement this interface can be sorted
* automatically by {@link Collections#sort(List) Collections.sort} (and
* {@link Arrays#sort(Object[]) Arrays.sort}). Objects that implement this
* interface can be used as keys in a {@linkplain SortedMap sorted map} or as
* elements in a {@linkplain SortedSet sorted set}, without the need to
* specify a {@linkplain Comparator comparator}.<p>
* 实现此接口的对象列表(和数组)可以通过Collections#sort(List)
* (和Arrays#sort(Object[])自动排序。
* 实现此接口的对象可以用作SortedMap中的键或SortedSet中的元素,
* 而无需指定Comparator。
*
*
*
*
*
*
* The natural ordering for a class {@code C} is said to be <i>consistent
* with equals</i> if and only if {@code e1.compareTo(e2) == 0} has
* the same boolean value as {@code e1.equals(e2)} for every
* {@code e1} and {@code e2} of class {@code C}. Note that {@code null}
* is not an instance of any class, and {@code e.compareTo(null)} should
* throw a {@code NullPointerException} even though {@code e.equals(null)}
* returns {@code false}.<p>
* 一个类C的自然顺序被称为与equals一致当且仅当e1.compareTo(e2) == 0
* 对于类C的每个e1和e2具有与e1.equals(e2)相同的布尔值。
* 请注意,null不是任何类的实例,e.compareTo(null)
* 应该抛出一个NullPointerException,即使e.equals(null)返回false
*
*
*
*
*
*
* It is strongly recommended (though not required) that natural orderings be
* consistent with equals. This is so because sorted sets (and sorted maps)
* without explicit comparators behave "strangely" when they are used with
* elements (or keys) whose natural ordering is inconsistent with equals. In
* particular, such a sorted set (or sorted map) violates the general contract
* for set (or map), which is defined in terms of the {@code equals}
* method.<p>
* 强烈建议(尽管不是必需的)自然顺序与equals一致。
* 这是因为没有显式比较器的排序集(和排序映射)
* 在与自然顺序与equals不一致的元素(或键)一起使用时表现“奇怪”。
* 特别是,这样的排序集(或排序映射)违反了集合(或映射)的一般约定,
* 该约定是根据equals方法定义的。
*
*
*
* For example, if one adds two keys {@code a} and {@code b} such that
* {@code (!a.equals(b) && a.compareTo(b) == 0)} to a sorted
* set that does not use an explicit comparator, the second {@code add}
* operation returns false (and the size of the sorted set does not increase)
* because {@code a} and {@code b} are equivalent from the sorted set's
* perspective.<p>
* 例如,如果向不使用显式比较器的排序集添加两个键a和b,
* 使得(!a.equals(b) && a.compareTo(b) == 0)到不使用显式比较器的排序集,
* 则第二个add操作返回false(并且排序集的大小不会增加),
* 因为a和b从排序集的角度来看是等价的。
*
*
* Virtually all Java core classes that implement {@code Comparable} have natural
* orderings that are consistent with equals. One exception is
* {@code java.math.BigDecimal}, whose natural ordering equates
* {@code BigDecimal} objects with equal values and different precisions
* (such as 4.0 and 4.00).<p>
* 实际上,所有实现Comparable的Java核心类都具有与equals一致的自然顺序。
* 一个例外是java.math.BigDecimal,它的自然顺序等于BigDecimal对象的值相等,
* 精度不同(如4.0和4.00)。
*
*
*
* For the mathematically inclined, the <i>relation</i> that defines
* the natural ordering on a given class C is:
* 对于具有数学倾向的类,定义给定类C上自然顺序的关系为:
*
* <pre>{@code
* {(x, y) such that x.compareTo(y) <= 0}.
* }</pre>
*
* The <i>quotient</i> for this total order is:
* 此总顺序的商为:
* <pre>{@code
* {(x, y) such that x.compareTo(y) == 0}.
* }</pre>
*
*
*
* It follows immediately from the contract for {@code compareTo} that the
* quotient is an <i>equivalence relation</i> on {@code C}, and that the
* natural ordering is a <i>total order</i> on {@code C}. When we say that a
* class's natural ordering is <i>consistent with equals</i>, we mean that the
* quotient for the natural ordering is the equivalence relation defined by
* the class's {@link Object#equals(Object) equals(Object)} method:
* 从compareTo的契约中可以看出,商是C上的等价关系,自然序是C上的总序。
* 当我们说类的自然顺序与equals一致时,
* 我们的意思是自然顺序的商是由类的Object#equals(Object)方法定义的等价关系:
*
*
* <pre>
* {(x, y) such that x.equals(y)}.
* </pre><p>
*
*
* This interface is a member of the
* <a href="{@docRoot}/java/util/package-summary.html#CollectionsFramework">
* Java Collections Framework</a>.
*
* @param <T> the type of objects that this object may be compared to
*
* @author Josh Bloch
* @see java.util.Comparator
* @since 1.2
*/
public interface Comparable<T> {
/**
* Compares this object with the specified object for order. Returns a
* negative integer, zero, or a positive integer as this object is less
* than, equal to, or greater than the specified object.
* 将此对象与订单的指定对象进行比较。
* 当此对象小于、等于或大于指定对象时,返回负整数、零或正整数。
*
* <p>The implementor must ensure
* {@code sgn(x.compareTo(y)) == -sgn(y.compareTo(x))}
* for all {@code x} and {@code y}. (This
* implies that {@code x.compareTo(y)} must throw an exception if
* {@code y.compareTo(x)} throws an exception.)
* 实现者必须确保所有x和y的sgn(x.compareTo(y)) == -sgn(y.compareTo(x))
* (这意味着如果y.compareTo(x)引发异常,x.compareTo(y)必须引发异常。)
*
*
*
*
* <p>The implementor must also ensure that the relation is transitive:
* {@code (x.compareTo(y) > 0 && y.compareTo(z) > 0)} implies
* {@code x.compareTo(z) > 0}.
* 实现者还必须确保关系是可传递的:
* (x.compareTo(y) > 0 && y.compareTo(z) > 0)意味着x.compareTo(z)>0}。
*
* <p>Finally, the implementor must ensure that {@code x.compareTo(y)==0}
* implies that {@code sgn(x.compareTo(z)) == sgn(y.compareTo(z))}, for
* all {@code z}.
* 最后,实现者必须确保x.compareTo(y)==0对于所有z,
* 意味着sgn(x.compareTo(z)) == sgn(y.compareTo(z))
*
*
*
*
* <p>It is strongly recommended, but <i>not</i> strictly required that
* {@code (x.compareTo(y)==0) == (x.equals(y))}. Generally speaking, any
* class that implements the {@code Comparable} interface and violates
* this condition should clearly indicate this fact. The recommended
* language is "Note: this class has a natural ordering that is
* inconsistent with equals."
* 强烈建议,但不是严格要求(x.compareTo(y)==0) == (x.equals(y))。
* 一般来说,任何实现{@code Comparable}接口并违反此条件的类都应该清楚地指出这一事实。
* 建议使用的语言是“注意:此类具有与equals不一致的自然顺序。”
*
*
*
*
* <p>In the foregoing description, the notation
* {@code sgn(}<i>expression</i>{@code )} designates the mathematical
* <i>signum</i> function, which is defined to return one of {@code -1},
* {@code 0}, or {@code 1} according to whether the value of
* <i>expression</i> is negative, zero, or positive, respectively.
* 在前面的描述中,符号sgn(表达式)指定数学符号函数,
* 该函数被定义为根据表达式的值是负、零还是正分别返回-1、0或1中的一个。
*
* @param o the object to be compared. 要比较的对象。
* @return a negative integer, zero, or a positive integer as this object
* is less than, equal to, or greater than the specified object.
* 负整数、零或正整数,因为此对象小于、等于或大于指定对象。
*
* @throws NullPointerException if the specified object is null
* @throws ClassCastException if the specified object's type prevents it
* from being compared to this object.
*/
public int compareTo(T o);
}