對于幾大傳統的排序演算法我在前面博客中已經介紹過了，如果有想要了解的同學可以去看這篇博客八大排序：冒泡排序，選擇排序，插入排序，堆排序，希爾排序，歸并排序，計數排序但是我們在刷題程序中如果題目中沒有對排序演算法做特別要求，排序只是當前題目的一個小程序的話我們大可不必自己實作以便排序演算法，因為Java中已經提供了幾個對資料做排序的方法，

用Array.sort()進行排序

Java中對陣列型別的資料有Array.sort(),具體如下：

使用上圖第一個多載：

//用Java中有的資料型別做陣列
 public static void main(String[] args) {
        int[] array = { 5, 3, 2, 1, 4, 6, 9, 8};
        Arrays.sort(array);
        System.out.println(Arrays.toString(array));
    }

運行結果：

如果用自己的實作類做陣列的話因為在排序程序中需要比較兩個元素的大小，這個實作類必須實作Comparable介面（這篇博客會用到Comparable和Comparator兩個介面，不會的同學請補這篇博客：Java中的Comparable和Comparator到底該怎么用看完就全明白了）：

//這是一個自己的實作類Ha，并且這個類實作了Comparable介面，
//意味著同型別物件之間可以進行比較
public class Ha implements Comparable<Ha>{
    int haVal;
    public Ha(int h ){
        haVal = h;
    }

    @Override
    public String toString() {
        return
                "haVal=" + haVal
               ;
    }

    @Override
    public int compareTo(Ha o) {
        //因為方法是拿當前物件compareTo傳入物件o
        //所以：
        //回傳負數表示當前物件比傳入物件o小
        //回傳正數反之
        return this.haVal - o.haVal;
    }
}

下面構建一個Ha[]陣列并對它排序：

public class Demo7 {
    public static void main(String[] args) {
        //創建幾個Ha型別物件
        Ha a = new Ha(1);
        Ha b = new Ha(2);
        Ha c = new Ha(3);
        Ha d = new Ha(4);
        Ha e = new Ha(5);
        Ha f = new Ha(6);
        //將上面的物件放到Ha[]陣列中
        Ha[] array = {f, d, c, e, b, a};

        Arrays.sort(array);
        System.out.println(Arrays.toString(array));
    }
}

運行結果：

使用第二個多載：

public static void main(String[] args) {
        int[] array = { 5, 3, 2, 1, 4, 6, 9, 8};
        //只會對指定區間內的資料排序，而且是左閉右開
        Arrays.sort(array, 0, 3);
        System.out.println(Arrays.toString(array));
    }

運行結果：

很明顯他只對[fromIndex, toIndex)區間做了排序，

使用第三個多載：

這個方法是在排序的時候傳入陣列的同時傳入一個比較器，傳入比較器有什么用呢？

1. 對于已經實作了Comparable的類（Integer等基礎型別的包裝類都實作了Comparable介面）來說sort方法會將它們按規則升序排序，如果你想降序排序那么你可以在這里傳入一個比較器來實作目的：

public static void main(String[] args) {
        Integer[] array = { 5, 3, 2, 1, 4, 6, 9, 8};
        Arrays.sort(array, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
        System.out.println(Arrays.toString(array));
    }

運行結果：

這里需要注意使用這個多載陣列型別不能是int，short等基礎資料型別，需要的是他們的包裝類，

2. 對于沒有實作Comparable的自己的類，可以在使用該多載的時候傳入一個Comparator，而不用在回去給自己的類實作Comparable（相信對這兩個比較介面不熟悉的同學這會已經暈了，去補博客吧哈哈）

//這是一個沒有實作Comparable介面的Ha類
public class Ha {
    int haVal;
    public Ha(int h ){
        haVal = h;
    }

    @Override
    public String toString() {
        return
                "haVal=" + haVal
               ;
    }
}

如果使用這個類去做sort的時候會報錯：

public static void main(String[] args) {
        //創建幾個Ha型別物件
        Ha a = new Ha(1);
        Ha b = new Ha(2);
        Ha c = new Ha(3);
        Ha d = new Ha(4);
        Ha e = new Ha(5);
        Ha f = new Ha(6);
        //將上面的物件放到Ha[]陣列中
        Ha[] array = {f, d, c, e, b, a};
		//直接排序
        Arrays.sort(array);
        System.out.println(Arrays.toString(array));
    }

傳入了一個Comparator就可以了：

 public static void main(String[] args) {
        Ha a = new Ha(1);
        Ha b = new Ha(2);
        Ha c = new Ha(3);
        Ha d = new Ha(4);
        Ha e = new Ha(5);
        Ha f = new Ha(6);
       Ha[] array = {f, b, c, d, a};
       Arrays.sort(array, new Comparator<Ha>() {
           @Override
           public int compare(Ha o1, Ha o2) {
               return o1.haVal - o2.haVal;
           }
       });
        System.out.println(Arrays.toString(array));
    }

運行結果：

對于第四個多載：

可以結合第二個和第三個去理解，

Arrays.parallelSort() 是什么 和 Array.sort()有什么區別

與Array.sort()不同的是Arrays.parallelSort() 是并行排序，就是java會將待排序陣列分成好幾個部分，然后創建好幾個執行緒去對不同的部分同時進行排序最后將各個執行緒的排序結果歸并到一起，聽起來好像Arrays.parallelSort() 要比Array.sort()快一些，其實則不然，因為創建執行緒這個操作會有性能的損耗，如果資料量小的時候再去創建多執行緒那么速度并沒有Array.sort()快，只有當資料量很大的時候用 Arrays.parallelSort()會比 Array.sort()快，那么這個界限是多少呢？Java在實作Arrays.parallelSort()時候做了規定當資料量小于8192的時候即使呼叫Arrays.parallelSort()，系統還是會選擇Array.sort()去做排序，
至于Arrays.parallelSort()方法的多載其實和 Array.sort()都差不多，只是前者背后有了并行排序這個操作，

所以對于Arrays.parallelSort()的這幾個多載大家對照這Array.sort()的去理解就好了

用 Collections.sort()進行排序

這個方法是對List進行排序：

要求還是和Arrays.sort()一樣，需要List內的元素的實作類實作Comparable介面或者，如第二個多載所示在排序時傳入一個Comparator就可了，這里就不做過多贅述了，直接演示：

 //當傳入的類實作了Comparable介面時可以直接對list排序
    public static void main(String[] args) {
        Ha a = new Ha(1);
        Ha b = new Ha(2);
        Ha c = new Ha(3);
        Ha d = new Ha(4);
        Ha e = new Ha(5);
        Ha f = new Ha(6);
        List<Ha> list = new ArrayList<>();
        list.add(b);
        list.add(c);
        list.add(d);
        list.add(a);
        list.add(f);
        list.add(e);
        //默認升序
        Collections.sort(list);
        System.out.println(list);
    }

運行結果：

 public static void main(String[] args) {
        //沒有實作Comparable介面的類需要傳入Comparator
        Ha a = new Ha(1);
        Ha b = new Ha(2);
        Ha c = new Ha(3);
        Ha d = new Ha(4);
        Ha e = new Ha(5);
        Ha f = new Ha(6);
        List<Ha> list = new ArrayList<>();
        list.add(b);
        list.add(c);
        list.add(d);
        list.add(a);
        list.add(f);
        list.add(e);
        //默認升序
        Collections.sort(list, new Comparator<Ha>() {
            @Override
            public int compare(Ha o1, Ha o2) {
                //回傳值是負數說明前者比后者小
                return o1.haVal - o2.haVal;
            }
        });
        System.out.println(list);
    }

運行結果：