冒泡循环_借鉴大神加自己的理解。

第一种方法
public static void maoPao() {

    int[] arr = { 6, 3, 8, 2, 9, 1 };
    System.out.println("排序前数组为：");
    for (int num : arr) {
        System.out.print(num + " ");
    }
    for (int i = 0; i < arr.length - 1; i++) {// 外层循环控制排序趟数 ，因为6个数，只需要循环5次就行。所以减1
        for (int j = 0; j < arr.length - 1 - i; j++) {// 内层循环控制每一趟排序多少次

            //外圈循环：arr.length - 1 
              //例如长度为6；说明是6个数进行比较，因此只需要比较5次就可以了。

            //内圈循环：arr.length - 1 - i
            // 减 1： 因为下面是 (arr[j] > arr[j + 1]  比较，如果不减1，
            //当j最大的时候，arr[j + 1] 就会报错，超出数组长度

             //减  i  :  例如当 i = 1时，说明第一次循环结束，刚开始第二次外循环，
              //经过第一次循环之后，最后一个数就是最大的，
            //没有必要每次循环都在此进行和最后一个最大的比较的。

             //比较原理
              //相邻的两两比较。
             // 例如：内循环开始时， j=0；arr[j]  和   arr[j+1]  就是  
              //arr[0]  和  arr[1]  比较，如果  arr[0]  大于  arr[1]  就让两个数的值互换，
              //arr【0】获得数值较小值，arr【1】获得较大的值。当内循环开始第二次，j=1，
               //arr【0】就不再比较，arr【1】和arr【2】
              // 比较，直到最大值到最后一位。然后再次开始外循环，获得第二小的最大值。直到结束。
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }

    System.out.println();
    System.out.println("排序后的数组为：");
    for (int num : arr) {
        System.out.print(num + " ");
    }

}

第二种方法

public static void maoPao2() {

    int[] unsorted = { 6, 3, 8, 2, 9, 1 };
    System.out.println("排序前数组为：");
    for (int num : unsorted) {
        System.out.print(num + " ");
    }
    System.out.println(unsorted.length);
    for (int i = 0; i < unsorted.length - 1; i++) {
        // 当j=i；说明先比较第一个，第一个比较完成之后，后面的循环就不在比较了。

        // 当i=0；unsorted[i]就是unsorted[0]，说明这是第一次循环，
        //  把unsorted[0]和unsorted[j]（j从1一直变化到最大值）

        // 期间unsorted[0]依次和它们比较，如果unsorted[0]大于其中一个就相互换值
         // ，直到unsorted[0]是最小的
        // 当第二次循环开始的时候，i=1；内循环直接放弃unsorted[0]的比较，
         //直接从unsorted[1]开始和unsorted[j]开始进行比较，然后确定第二小的值
        // 直到循环结束，从小到大
        for (int j = i; j < unsorted.length; j++) {

            if (unsorted[i] > unsorted[j+1]) {

                int temp = unsorted[i];
                unsorted[i] = unsorted[j+1];
                unsorted[j+1] = temp;
            }
        }
    }

    System.out.println();
    System.out.println("排序后的数组为：");
    for (int num : unsorted) {
        System.out.print(num + " ");
    }

}

第三种方法
//前面两个方法都是先获得最大的数放在最后，然后获得第二小的数。
//这个方法是先获得最小的数，然后依次获得第二小的数。
private void core(int[] array) {

    int arrayLength = array.length;

    for (int i = 0; i < arrayLength; i++) {
        for (int j = arrayLength - 2; j >= i; j--) {
            if (array[j] > array[j + 1]) {
                ArrayUtils.swap(array, j, j + 1);
            }
        }
    }
}

第四种方法（双向冒泡排序）

说明：从一个数组的开头和结尾同时开始排序，当到中间时结束。
同时获得最大的数和最小的数，分别放在开始和结尾。然后获得第二
小的数和第二大的数放在第二位和倒数第二位，直到中间碰头。

private void core(int[] array) {
int arrayLength = array.length;

    int preIndex = 0;
    int backIndex = arrayLength - 1;
    while(preIndex < backIndex) {
        preSort(array, arrayLength, preIndex);
        preIndex++;

        if (preIndex >= backIndex) {
            break;
        }

        backSort(array, backIndex);
        backIndex--;
    }
}

// 从前向后排序
private void preSort(int[] array, int length, int preIndex) {
    for (int i = preIndex + 1; i < length; i++) {
        if (array[preIndex] > array[i]) {
            ArrayUtils.swap(array, preIndex, i);
        }
    }
}

// 从后向前排序
private void backSort(int[] array, int backIndex) {
    for (int i = backIndex - 1; i >= 0; i--) {
        if (array[i] > array[backIndex]) {
            ArrayUtils.swap(array, i, backIndex);
        }
    }
}