Comparable接口的实现和使用

实现Comparable接口的compareTo方法 排序

该接口强行对实现它的每个类的对象进行整体排序。此排序被称为该类的自然排序 ，类的 compareTo 方法被称为它的自然比较方法 。实现此接口的对象列表（和数组）可以通过 Collections.sort （和 Arrays.sort ）进行自动排序。如Jdk 中 Long 根据 value 大小进行排序

---

Long 类

    /**
     * Compares two {@code Long} objects numerically.
     *
     * @param   anotherLong   the {@code Long} to be compared.
     * @return  the value {@code 0} if this {@code Long} is
     *          equal to the argument {@code Long}; a value less than
     *          {@code 0} if this {@code Long} is numerically less
     *          than the argument {@code Long}; and a value greater
     *          than {@code 0} if this {@code Long} is numerically
     *           greater than the argument {@code Long} (signed
     *           comparison).
     * @since   1.2
     */
    public int compareTo(Long anotherLong) {
        return compare(this.value, anotherLong.value);
    }

    /**
     * Compares two {@code long} values numerically.
     * The value returned is identical to what would be returned by:
     * <pre>
     *    Long.valueOf(x).compareTo(Long.valueOf(y))
     * </pre>
     *
     * @param  x the first {@code long} to compare
     * @param  y the second {@code long} to compare
     * @return the value {@code 0} if {@code x == y};
     *         a value less than {@code 0} if {@code x < y}; and
     *         a value greater than {@code 0} if {@code x > y}
     * @since 1.7
     */
    public static int compare(long x, long y) {
        return (x < y) ? -1 : ((x == y) ? 0 : 1);
    }

Test.java

    public static void main(String[] args) {
        List<Long> longList = new ArrayList<>();
        longList.add(10L);//添加 并不会去排序
        longList.add(0L);
        longList.add(30L);
        longList.add(20L);


        System.out.println("sort before");
        for (Long l : longList) {
            System.out.println(l);
        }

        Collections.sort(longList);
        System.out.println("sort after");
        for (Long l : longList) {
            System.out.println(l);
        }
    }

运行结果如图：

接下来 新建 Person 类，以age 属性进行排序

public class Person implements Comparable<Person> {
    String name;
    int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }


    @Override
    public int compareTo(Person o) {
        //比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数。
        return compare(this.age, o.age);
    }

    /**
     * @param age1
     * @param age2
     * @return
     */
    public static int compare(long age1, long age2) {
        return (age1 > age2 ? 1 :
                (age1 == age2 ? 0 : -1));
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

Test.java

public static void main(String[] args) {
        Person person = new Person("小明",12);
        Person person2 = new Person("小红",11);
        Person person3= new Person("小宝",14);
        List<Person> personList = new ArrayList<>();
        personList.add(person);
        personList.add(person2);
        personList.add(person3);

        System.out.println("sort before");
        for (Person person1 : personList) {
            System.out.println(person1.toString());
        }

        Collections.sort(personList);
        System.out.println("sort after");
        for (Person person1 : personList) {
            System.out.println(person1.toString());
        }
    }

运行结果如图：

so easy!

sort 原理

Collections.sort(..);

跟随jdk 源码，这里是jdk1.8.
ArrayList中的 default sort Method 还是 调用了Arrays.sort() 方法，

public static <T> void sort(T[] a, int fromIndex, int toIndex,
                                Comparator<? super T> c) {
        if (c == null) {
            sort(a, fromIndex, toIndex);
        } else {
            rangeCheck(a.length, fromIndex, toIndex);
            if (LegacyMergeSort.userRequested)
                legacyMergeSort(a, fromIndex, toIndex, c);
            else
                TimSort.sort(a, fromIndex, toIndex, c, null, 0, 0);
        }
    }
public static void sort(Object[] a, int fromIndex, int toIndex) {
        rangeCheck(a.length, fromIndex, toIndex);
        if (LegacyMergeSort.userRequested)
            legacyMergeSort(a, fromIndex, toIndex);
        else
            ComparableTimSort.sort(a, fromIndex, toIndex, null, 0, 0);
    }

    /** To be removed in a future release. */
    private static void legacyMergeSort(Object[] a,
                                        int fromIndex, int toIndex) {
        Object[] aux = copyOfRange(a, fromIndex, toIndex);
        mergeSort(aux, a, fromIndex, toIndex, -fromIndex);
    }

源码中涉及排序的知识，以后再讲

最后

Comparable接口的实现和使用其实非常简单的，Jdk 都为我们实现了，我们了解原理及使用。