JAVA中的排序函数包括java.util.Arrays包中的Arrays.sort();java.util.Collections包中的Collections.sort()

1.Arrays.sort()函数具有以下几种重载：

java datata java datatable 排序函数_数组

以static void sort(T[] a, int fromIndex, int toIndex, Comparator<? super T> c)为例说明该函数的使用方法
函数在输入的数组上排序，返回值为空
该函数参数列表含义：a表示输入数组；fromIndex表示数组a中需要排序部分的起始索引（包括该索引对应的值）；toIndex表示数组a中需要排序部分的结束索引（不包括该索引对应的值）；c表示自定义比较器（用户可以自己定义比较器用于对非数字数组排序）
例如：
public class Sort {
    public static Integer[] sort(Integer[] arr){
        Arrays.sort(arr, 0, arr.length, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 - o2;
            }
        });
        return arr;
    }

    public static void main(String[] args) {
        Integer[] ints = {5, 3, 9, 8, 1, 2, 0, 3, 5};
        Integer[] n = sort(ints);
        for (int i:n) {
            System.out.print(i);
            System.out.print(',');
        }
    }
}
//排序结果为：0,1,2,3,3,5,5,8,9
改变Comparator中的（return o1 - o2;）为（return o2 - o1;），可以使排序为降序排序
Arrays.sort(arr, 0, arr.length, new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        return o2 - o1;
    }
});
//排序结果为：9,8,5,5,3,3,2,1,0
改变Comparator匿名类可以实现字符串、对象这些非数字的排序
2.Collections.sort()函数具有以下几种重载：

java datata java datatable 排序函数_java_02

static <T> void sort(List<T> list, Comparator<? super T> c)为例
函数在输入的列表上排序，返回值为空
该函数参数列表含义：a表示输入列表；c表示自定义比较器
例如：
public class CSort {
    public static List<Integer> sort(List<Integer> arr){
        Collections.sort(arr, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 - o2;
            }
        });
        return arr;
    }

    public static void main(String[] args) {
        Integer[] m = new Integer[]{5,8,5,4,6,14,8,6};
        ArrayList<Integer> list = new ArrayList<Integer>(Arrays.asList(m));
        System.out.println(sort(list));
    }
}
//排序结果为：[4, 5, 5, 6, 6, 8, 8, 14]
改变Comparator中的（return o1 - o2;）为（return o2 - o1;），可以使排序为降序排序
Collections.sort(arr, new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        return o2 - o1;
    }
});
//排序结果为：[14, 8, 8, 6, 6, 5, 5, 4]
改变Comparator匿名类可以实现字符串、对象这些非数字的排序
3.List中的sort(Comparator<? super E> c)
例如
public class ListSort {
    public static List<Integer> sort(List<Integer> c){
        c.sort(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 - o2;
            }
        });
        return c;
    }
    public static void main(String[] args) {
        Integer[] m = new Integer[]{5,8,5,4,6,14,8,6};
        ArrayList<Integer> list = new ArrayList<Integer>(Arrays.asList(m));
        System.out.println(sort(list));
    }
}
//排序结果为：[4, 5, 5, 6, 6, 8, 8, 14]
改变Comparator中的（return o1 - o2;）为（return o2 - o1;），可以使排序为降序排序
c.sort(new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        return o2 - o1;
    }
});
//排序结果为：[14, 8, 8, 6, 6, 5, 5, 4]
改变Comparator匿名类可以实现字符串、对象这些非数字的排序
4.Arrays包下的parallelSort()函数用法

java datata java datatable 排序函数_数组_03

排序算法是一个并行排序合并，将数组分解为本身排序然后合并的子数组。 当子阵列长度达到最小粒度时，使用适当的Arrays.sort方法对子阵列进行排序。 如果指定数组的长度小于最小粒度，则使用适当的Arrays.sort方法进行排序。 该算法需要一个不大于原始数组大小的工作空间。 ForkJoin common pool用于执行任何并行任务。
例如以下的逆序排序：
public class ParallelSort {
    public static Integer[] sort(Integer[] c) {
        Arrays.parallelSort(c, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
        return c;
    }

    public static void main(String[] args) {
        Integer[] m = new Integer[]{5,8,5,4,6,14,8,6};
        Integer[] n = sort(m);
        for (int i:n) {
            System.out.print(i);
            System.out.print(',');
        }
    }
}
//排序结果为：14,8,8,6,6,5,5,4