排序規則

排序的規則主要應用在兩個大型別上面，一個是基本資料型別（按照日常的大小排序），另外一個就是引用資料型別（包括內建類和自定義的類）。
對於引用資料型別：
內建類：內部已經自定義了規則，直接可以使用。如Integer、String等型別都是繼承了Comparable介面的，都重寫了ComparaTo方法。觀其原始碼如下：

  //Integer的排序原始碼
  public int compareTo(Integer anotherInteger) {
      return compare(this.value, anotherInteger.value);
  }


  public
 
 static int compare(int x, int y) {
      return (x < y) ? -1 : ((x == y) ? 0 : 1);
  }

  //String型別的排序原始碼
  public int compareTo(String anotherString) {
      int len1 = value.length;
      int len2 = anotherString.value.length;
      int lim = Math.min(len1, len2);
      char v1[] = value;
      char
 
 v2[] = anotherString.value;

      int k = 0;
      while (k < lim) {
          char c1 = v1[k];
          char c2 = v2[k];
          if (c1 != c2) {
              return c1 - c2; //先從前至後比較單個字母的Unicode碼
          }
          k++;
      }
      return len1 - len2; //如果字母一樣的話就比較長度
  }

氣泡排序

• 氣泡排序：基本思想是比較相鄰元素值，如果滿足條件就交換元素值。
• 直接選擇排序：排序速度比冒泡速度快一些，基本思想是將制定排序位置與其他陣列元素分別對比，如果滿足條件就交換元素值，注意這裡區別氣泡排序，不是交換相鄰元素，而是把滿足條件的元素與制定的排序位置交換。

import java.util.Arrays;


public class testorder {
    public static void main(String[] args) {
        int[] arr = new int[]{64,2,3,55,44,23,1};
//      Arrays.sort(arr);
        testorder a = new testorder();
//      a.sort1(arr);
        a.showit(arr);
        System.out.println();
        System.out.println("******************");
        a.reverseSort(arr);
        int index = Arrays.binarySearch(arr,2);
        System.out.println();
        System.out.println("檢索該數在陣列中位置為："+index);

    }

    //氣泡排序方法
    public static void sort(int arr[]){
        int temp = 0;
        //最終版
        boolean sorted = true;
        for(int i=0;i<arr.length-1;i++){
            for(int j=0;j<arr.length-i-1;j++){
                if(arr[j]>arr[j+1]){
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                    sorted = false;
                }
            }
            if(sorted){
                break;
            }
        }
        showit(arr);
    }


    // 直接排序法，相對執行時間比氣泡排序的時間要短,每一趟從排序的資料元素中選出最小
    // 或者最大的一個元素，順序的放在已經排好的序列的而最後，直到資料元素排序完畢
    public void sort1(int arr[]){
        for(int i = 1;i<arr.length;i++){
            int index = 0;
            for(int j = 1;j<=arr.length-i;j++){
                if(arr[j]>arr[index]){
                    index = j;
                }
            }
            int temp = arr[arr.length-i];
            arr[arr.length-i] = arr[index];
            arr[index] = temp;
        }
        showit(arr);
    }

    //測試陣列的反轉排序
    public void reverseSort(int arr[]){
        int j = arr.length;
        for(int i = 0;i<arr.length/2;i++){
            int temp = arr[i];
            arr[i] = arr[j-i-1];
            arr[j-i-1] = temp;
        }
        showit(arr);
    }

    //利用foreach逐步列印要列印的陣列
    public void showit(int arr[]){
        for(int i:arr){
            System.out.print(i+"\t");
        }
    }   
}