Collections.sort和Arrays.sort比较

Collections.sort

@SuppressWarnings("unchecked")
    public static > void sort(List list) {
        list.sort(null);
    }
    @SuppressWarnings({"unchecked", "rawtypes"})
    public static  void sort(List list, Comparator c) {
        list.sort(c);
    }

由jdk源码我们可知，Collections类中的sort函数提供了两种重载。

第一种方法：

>该方法的泛型必须实现了Comparable中的compareTo()方法，输入为相应的List。

第二种方法：

对泛型不作要求，但是输入参数中需提供Comparator

我们可以通过例子来分析：

public class run {
    
    public static void main(String[] args) throws Exception 
    {
        //类A实现了Comparable接口，所以可以直接使用Collections.sort()方法
        A a1 = new A(3);
        A a2 = new A(1);
        A a3 = new A(2);
        ArrayList lista = new ArrayList();
        lista.add(a1);
        lista.add(a2);
        lista.add(a3);
        Collections.sort(lista);
        for(A a : lista)
            System.out.println(a.value);//输出123
        
        //类B没有实现Comparable接口，通过自定义的比较器Comparator来使用Collections.sort()方法
        ArrayList listb = new ArrayList();
        B b1 = new B(5);
        B b2 = new B(7);
        B b3 = new B(6);
        listb.add(b1);
        listb.add(b2);
        listb.add(b3);
        BComparator comparator = new BComparator();
        Collection.sort(listb);//错误，会报错，缺少比较器
        Collections.sort(listb, comparator);//正确
        for(B b : listb)
            System.out.print(b.value);//输出567
    }

}
//类A实现了Comparble接口
class A implements Comparable {
    public int value;
    //升序排列
    @Override
    public int compareTo(A o) {
        if(this.value > o.value)
            return 1;
        else if(this.value < o.value)
            return -1;
        else
            return 0;
    }
    public A (int i) {
        value = i;
    }
}
//类B是一个普通类
class B {
    public int value;
    public B(int i) {
        value = i;
    }
}
//定义比较器，实现了Comparator接口，可以用来作为输入参数定义比较方法
class BComparator implements Comparator {
    //升序排列
    @Override
    public int compare(B o1, B o2) {
        if(o1.value > o2.value)
            return 1;
        else if(o1.value < o2.value)
            return -1;
        else
            return 0;
    }
    
}

Arrays.sort

由jdk源码可知，Arrays.sort方法也可以通过自定义Comparator的方法来实现自定义排序。

/*
     * @param  the class of the objects to be sorted
     * @param a the array to be sorted
     * @param c the comparator to determine the order of the array.  A
     *        {@code null} value indicates that the elements'
     *        {@linkplain Comparable natural ordering} should be used.
     * @throws ClassCastException if the array contains elements that are
     *         not mutually comparable using the specified comparator
     * @throws IllegalArgumentException (optional) if the comparator is
     *         found to violate the {@link Comparator} contract
     */
    public static  void sort(T[] a, Comparator c) {
        if (c == null) {
            sort(a);
        } else {
            if (LegacyMergeSort.userRequested)
                legacyMergeSort(a, c);
            else
                TimSort.sort(a, 0, a.length, c, null, 0, 0);
        }
    }

    /** To be removed in a future release. */
    private static  void legacyMergeSort(T[] a, Comparator c) {
        T[] aux = a.clone();
        if (c==null)
            mergeSort(aux, a, 0, a.length, 0);
        else
            mergeSort(aux, a, 0, a.length, 0, c);
    }
我们继续通过例子来分析：

public class run {
    
    public static void main(String[] args) throws Exception 
    {
        A a1 = new A(5);
        A a2 = new A(7);
        A a3 = new A(6);
        A[] array2 = new A[3];
        array2[0] = a1;
        array2[1] = a2;
        array2[2] = a3;
        Arrays.sort(array2);
        for(int i = 0; i < array2.length; i++) {
            System.out.print(array2[i].value);//输出567
        } 
        
        B b1 = new B(5);
        B b2 = new B(7);
        B b3 = new B(6);
        B[] array = new B[3];
        array[0] = b1;
        array[1] = b2;
        array[2] = b3;
        BComparator comparator = new BComparator();
        Arrays.sort(array);//错误,B没有实现Comparable接口，程序无法判断排序标准
        Arrays.sort(array, comparator);//正确
        for(int i = 0; i < array.length; i++) {
            System.out.print(array[i].value);//输出567
        }
    }
}
//类A实现了Comparble接口
class A implements Comparable {
    public int value;
    //升序排列
    @Override
    public int compareTo(A o) {
        if(this.value > o.value)
            return 1;
        else if(this.value < o.value)
            return -1;
        else
            return 0;
    }
    public A (int i) {
        value = i;
    }
}
//类B是一个普通类
class B {
    public int value;
    public B(int i) {
        value = i;
    }
}
//定义比较器，实现了Comparator接口，可以用来作为输入参数定义比较方法
class BComparator implements Comparator {
    //升序排列
    @Override
    public int compare(B o1, B o2) {
        if(o1.value > o2.value)
            return 1;
        else if(o1.value < o2.value)
            return -1;
        else
            return 0;
    }
}

总结

由上可知，Arrays.sort和Collections.sort实现自定义排序时基本相同，分为两种：

1）被排序的元素自身实现了Comparable接口

2）被排序的元素没有实现Comparable接口，自定义比较器Comparator类作为输入参数输入

区别：

Collection.sort是给List进行排序，而Arrays.sort是给数组进行排序。

PS:

回到Collections.sort的源码：

    @SuppressWarnings("unchecked")
    public static > void sort(List list) {
        list.sort(null);
    }
    @SuppressWarnings({"unchecked", "rawtypes"})
    public static  void sort(List list, Comparator c) {
        list.sort(c);
    }

我们发现调用了list.sort方法，查看该方法的源码

@SuppressWarnings({"unchecked", "rawtypes"})
    default void sort(Comparator c) {
        Object[] a = this.toArray();
        Arrays.sort(a, (Comparator) c);
        ListIterator i = this.listIterator();
        for (Object e : a) {
            i.next();
            i.set((E) e);
        }
    }

调用了Arrays.sort方法。

所以，其实Collections.sort实质上是调用的Arrays.sort