devbox
秋刀鱼在做梦
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

java基础进阶之数组排序-可能有你不知道的哦！！_java 降序和升序

作者：秋刀鱼在做梦 | 2024-07-23 00:15:10

赞

踩

java 降序和升序

1、使用Arrays类的sort方法

1.1、默认升序

        java中Arrays类提供了sort方法来进行快速排序，默认是升序的。

Arrays.sort(数组名)

  1. private static void ArrSort1(int[] arr) {
  2.         Arrays.sort(arr);
  3.         System.out.println("快速排序-默认升序:"+Arrays.toString(arr));
  4.     }

1.2、降序        

如果需要降序，写法如下：

//数组类型不能是基本数据类型

 Arrays.sort(数组名，Collections.reverseOrder())

  1. private static void ArrSort2(int[] arr) {
  2.         //数组类型不能是基本数据类型
  3.         Integer[] arrayInteger = Arrays.stream(arr).boxed().toArray(Integer[]::new);
  4.         Arrays.sort(arrayInteger, Collections.reverseOrder());
  5.         System.out.println("快速排序-降序:"+Arrays.toString(arrayInteger));
  6.     }

1.3、区间排序        

如果需要区间排序，写法如下：

//formIndex起始位置，toIndex结束位置

Arrays.sort(数组名,int formIndex, int toIndex)

  1. private static void ArrSort3(int[] arr) {
  2.         Arrays.sort(arr,1, 3);
  3.         System.out.println("快速排序-区间排序:"+Arrays.toString(arr));
  4.     }

1.4、重载排序

//数组类型不能是基本数据类型

Arrays.sort(数组名, new Comparator<数据类型对应的类>() {
    @Override
    public int compare(数据类型对应的类 o1, 数据类型对应的类 o2) {
        return 重载方式;
    }
});

  1. private static void ArrSort4(int[] arr) {
  2.         Integer[] arrayInteger = Arrays.stream(arr).boxed().toArray(Integer[]::new);
  3.         Arrays.sort(arrayInteger, new Comparator<Integer>() {
  4.             @Override
  5.             public int compare(Integer o1, Integer o2) {
  6.                 return o2 - o1;
  7.             }
  8.         });
  9.         System.out.println("快速排序-重载排序:"+Arrays.toString(arrayInteger));
  10.     }
  11.     private static void ArrSort5(int[] arr) {
  12.         Integer[] arrayInteger = Arrays.stream(arr).boxed().toArray(Integer[]::new);
  13.         //lambda表达式
  14.         Arrays.sort(arrayInteger, (o1, o2) -> o2 - o1);
  15.         System.out.println("快速排序-重载排序:"+Arrays.toString(arrayInteger));
  16.     }

2、冒泡排序

        冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。

        它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行，直到没有相邻元素需要交换，也就是说该元素列已经排序完成。

        这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。

2.1、原理

冒泡排序的原理如下：

  1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。

  2. 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。

  3. 针对所有的元素重复以上的步骤，除了最后一个。

  4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

2.2、示例图

2.3、时间复杂度

2.4、稳定性

        冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较，交换也发生在这两个元素之间。所以，如果两个元素相等，是不会再交换的；如果两个相等的元素没有相邻，那么即使通过前面的两两交换把两个相邻起来，这时候也不会交换，所以相同元素的前后顺序并没有改变，所以冒泡排序是一种稳定排序算法。

2.5、示例

  1.    private static void ArrSortM(int[] arr) {
  2.         for (int i = 0; i < arr.length - 1; i++) {
  3.             for (int j = 0; j < arr.length - 1 - i; j++) {
  4.                 // 升序：如果左边的数大于右边的数，则交换，保证右边的数字最大
  5.                 // 降序：如果左边的数小于右边的数，则交换，保证右边的数字最小
  6.                 if (arr[j] > arr[j + 1]) {
  7.                     int temp = arr[j];
  8.                     arr[j] = arr[j + 1];
  9.                     arr[j + 1] = temp;
  10.                 }
  11.             }
  12.         }
  13.         System.out.println("冒泡排序:"+Arrays.toString(arr));
  14.     }
  15.     private static void ArrSortM1(int[] arr) {
  16.         // 初始时 swapped 为 true，否则排序过程无法启动
  17.         boolean swapped = true;
  18.         for (int i = 0; i < arr.length - 1; i++) {
  19.             // 如果没有发生过交换，说明剩余部分已经有序，排序完成
  20.             if (!swapped) break;
  21.             // 设置 swapped 为 false，如果发生交换，则将其置为 true
  22.             swapped = false;
  23.             for (int j = 0; j < arr.length - 1 - i; j++) {
  24.                 if (arr[j] > arr[j + 1]) {
  25.                     // 如果左边的数大于右边的数，则交换，保证右边的数字最大
  26.                     int temp = arr[j];
  27.                     arr[j] = arr[j + 1];
  28.                     arr[j + 1] = temp;
  29.                     // 表示发生了交换
  30.                     swapped = true;
  31.                 }
  32.             }
  33.         }
  34.         System.out.println("冒泡排序1:"+Arrays.toString(arr));
  35.     }
  36.  
  37.     private static void ArrSortM2(int[] arr) {
  38.         for (int i = 0; i < arr.length - 1; i++) {
  39.             for (int j = 0; j < arr.length - 1 - i; j++) {
  40.                 // 不添加参数的写法
  41.                 // 升序：如果左边的数大于右边的数，则交换，保证右边的数字最大
  42.                 // 降序：如果左边的数小于右边的数，则交换，保证右边的数字最小
  43.                 if (arr[j] > arr[j + 1]) {
  44.                     arr[j + 1] = arr[j + 1] + arr[j];
  45.                     arr[j] = arr[j + 1] - arr[j];
  46.                     arr[j + 1] = arr[j + 1] - arr[j];
  47.                 }
  48.             }
  49.         }
  50.         System.out.println("冒泡排序2:"+Arrays.toString(arr));
  51.     }
  52.     private static void ArrSortM3(int[] arr) {
  53.         boolean swapped = true;
  54.         // 最后一个没有经过排序的元素的下标
  55.         int indexOfLastUnsortedElement = arr.length - 1;
  56.         // 上次发生交换的位置
  57.         int swappedIndex = -1;
  58.         while (swapped) {
  59.             swapped = false;
  60.             for (int i = 0; i < indexOfLastUnsortedElement; i++) {
  61.                 if (arr[i] > arr[i + 1]) {
  62.                     // 如果左边的数大于右边的数，则交换，保证右边的数字最大
  63.                     int temp = arr[i];
  64.                     arr[i] = arr[i + 1];
  65.                     arr[i + 1] = temp;
  66.                     // 表示发生了交换
  67.                     swapped = true;
  68.                     // 更新交换的位置
  69.                     swappedIndex = i;
  70.                 }
  71.             }
  72.             // 最后一个没有经过排序的元素的下标就是最后一次发生交换的位置
  73.             indexOfLastUnsortedElement = swappedIndex;
  74.         }
  75.         System.out.println("冒泡排序3:"+Arrays.toString(arr));
  76.     }

3、选择排序

3.1、原理

选择排序：通过不断选择数组中最小的元素，并将其放置在已排序部分的末尾，逐渐构建有序数组。

 3.2、示例图

 

3.3、时间复杂度

        选择排序的交换操作介于 0 和 (n - 1)次之间。选择排序的比较操作为 n (n - 1） / 2 次之间。选择排序的赋值操作介于 0 和 3 (n - 1） 次之间。比较次数O(n^2），比较次数与关键字的初始状态无关，总的比较次数N=(n-1）+(n-2）+...+1=n*(n-1）/2。交换次数O(n），最好情况是，已经有序，交换0次；最坏情况交换n-1次，逆序交换n/2次。交换次数比冒泡排序少多了，由于交换所需CPU时间比比较所需的CPU时间多，n值较小时，选择排序比冒泡排序快。

3.4、稳定性

        选择排序是给每个位置选择当前元素最小的，比如给第一个位置选择最小的，在剩余元素里面给第二个元素选择第二小的，依次类推，直到第n-1个元素，第n个元素不用选择了，因为只剩下它一个最大的元素了。那么，在一趟选择，如果一个元素比当前元素小，而该小的元素又出现在一个和当前元素相等的元素后面，那么交换后稳定性就被破坏了。举个例子，序列5 8 5 2 9，我们知道第一遍选择第1个元素5会和2交换，那么原序列中两个5的相对前后顺序就被破坏了，所以选择排序是一个不稳定的排序算法。

3.5、二元选择排序

        二元选择排序，每轮选择时记录最小值和最大值，可以把选择排序的效率提升一点，由于每一轮遍历可以排好两个数字，所以最外层的遍历只需遍历一半即可。

        经过优化之后，选择排序的效率提升了一点。但可惜的是，这样的优化无法改变时间复杂度，我们知道时间复杂度与常量系数无关，仍然是 O(n^2)。

3.6、示例

  1.     private static void ArrSortX(int[] arr) {
  2.         for (int i = 0; i < arr.length - 1; i++) {
  3.             int minIndex = i;
  4.             for (int j = i + 1; j < arr.length; j++) {
  5.                 if (arr[j] < arr[minIndex]) {
  6.                     minIndex = j;
  7.                 }
  8.             }
  9.             int temp = arr[i];
  10.             arr[i] = arr[minIndex];
  11.             arr[minIndex] = temp;
  12.         }
  13.         System.out.println("选择排序:"+ Arrays.toString(arr));
  14.     }
  15.     private static void ArrSortX1(int[] arr) {
  16.         int minIndex, maxIndex;
  17.         // i 只需要遍历一半
  18.         for (int i = 0; i < arr.length / 2; i++) {
  19.             minIndex = i;
  20.             maxIndex = i;
  21.             for (int j = i + 1; j < arr.length - i; j++) {
  22.                 if (arr[minIndex] > arr[j]) {
  23.                     // 记录最小值的下标
  24.                     minIndex = j;
  25.                 }
  26.                 if (arr[maxIndex] < arr[j]) {
  27.                     // 记录最大值的下标
  28.                     maxIndex = j;
  29.                 }
  30.             }
  31.             // 将最小元素交换至首位
  32.             int temp = arr[i];
  33.             arr[i] = arr[minIndex];
  34.             arr[minIndex] = temp;
  35.             // 如果最大值的下标刚好是 i，由于 arr[i] 和 arr[minIndex] 已经交换了，所以这里要更新 maxIndex 的值。
  36.             if (maxIndex == i) maxIndex = minIndex;
  37.             // 将最大元素交换至末尾
  38.             int lastIndex = arr.length - 1 - i;
  39.             temp = arr[lastIndex];
  40.             arr[lastIndex] = arr[maxIndex];
  41.             arr[maxIndex] = temp;
  42.         }
  43.         System.out.println("选择排序1:"+ Arrays.toString(arr));
  44.     }

4、插入排序

4.1、原理

        插入排序的思想非常简单，生活中有一个非常常见的场景：在打扑克牌时，我们一边抓牌一边给扑克牌排序，每次摸一张牌，就将它插入手上已有的牌中合适的位置，逐渐完成整个排序。

4.2、示例图

4.3、时间复杂度

        在插入排序中，当待排序数组是有序时，是最优的情况，只需当前数跟前一个数比较一下就可以了，这时一共需要比较N- 1次，时间复杂度为O(N)  

        最坏的情况是待排序数组是逆序的，此时需要比较次数最多，总次数记为：1+2+3+…+N-1，所以，插入排序最坏情况下的时间复杂度为0(N*N)

        平均来说，A[1..j-1]中的一半元素小于A[j]，一半元素大于A[j]。插入排序在平均情况运行时间与最坏情况运行时间一样，是输入规模的二次函数。

4.4、稳定性

        如果待排序的序列中存在两个或两个以上具有相同关键词的数据，排序后这些数据的相对次序保持不变，即它们的位置保持不变，通俗地讲，就是两个相同的数的相对顺序不会发生改变，则该算法是稳定的；如果排序后，数据的相对次序发生了变化，则该算法是不稳定的。关键词相同的数据元素将保持原有位置不变，所以该算法是稳定的。

4.5、示例

  1.     private static void ArrSortC(int[] arr) {
  2.         for (int i = 1; i < arr.length; i++) {
  3.             int key = arr[i];
  4.             int j = i - 1;
  5.             while (j >= 0 && arr[j] > key) {
  6.                 arr[j + 1] = arr[j];
  7.                 j--;
  8.             }
  9.             arr[j + 1] = key;
  10.         }
  11.     }

5、快速排序

        通过选择一个基准元素，将数组分成两部分，一部分小于基准元素，一部分大于基准元素，然后递归地对两部分进行排序。示例代码如下：

  1.     private static void ArrSortK(int[] arr, int low, int high) {
  2.         if (low < high) {
  3.             int pivotIndex = partition(arr, low, high);
  4.             ArrSortK(arr, low, pivotIndex - 1);
  5.             ArrSortK(arr, pivotIndex + 1, high);
  6.         }
  7.         System.out.println("快速排序:"+Arrays.toString(arr));
  8.     }
  9.  
  10.     private static int partition(int[] arr, int low, int high) {
  11.         int pivot = arr[high];
  12.         int i = low - 1;
  13.         for (int j = low; j < high; j++) {
  14.             if (arr[j] < pivot) {
  15.                 i++;
  16.                 int temp = arr[i];
  17.                 arr[i] = arr[j];
  18.                 arr[j] = temp;
  19.             }
  20.         }
  21.         int temp = arr[i + 1];
  22.         arr[i + 1] = arr[high];
  23.         arr[high] = temp;
  24.         return i + 1;
  25.     }

6、归并排序

        通过将数组分成两部分，分别对两部分进行排序，然后将两个有序的部分合并成一个有序数组。示例代码如下：

  1.    private static void ArrSortG(int[] arr, int low, int high) {
  2.         if (low < high) {
  3.             int mid = (low + high) / 2;
  4.             ArrSortG(arr, low, mid);
  5.             ArrSortG(arr, mid + 1, high);
  6.             merge(arr, low, mid, high);
  7.         }
  8.         System.out.println("归并排序:"+Arrays.toString(arr));
  9.     }
  10.     private static void merge(int[] array, int low, int mid, int high) {
  11.         int[] temp = new int[high - low + 1];
  12.         int i = low;
  13.         int j = mid + 1;
  14.         int k = 0;
  15.         while (i <= mid && j <= high) {
  16.             if (array[i] <= array[j]) {
  17.                 temp[k++] = array[i++];
  18.             } else {
  19.                 temp[k++] = array[j++];
  20.             }
  21.         }
  22.         while (i <= mid) {
  23.             temp[k++] = array[i++];
  24.         }
  25.         while (j <= high) {
  26.             temp[k++] = array[j++];
  27.         }
  28.         for (int m = 0; m < temp.length; m++) {
  29.             array[low + m] = temp[m];
  30.         }
  31.     }

 整体代码

  1. import java.util.Arrays;
  2. import java.util.Collections;
  3. import java.util.Comparator;
  4.  
  5. public class TestArray2 {
  6.     public static void main(String[] args) {
  7.         int[] arr = {3, 2, 1, 5, 4};
  8.         System.out.println("arr:"+Arrays.toString(arr));
  9.         //输出方式
  10.         //extracted(arr);
  11.  
  12.         //方法一：快速排序
  13.         ArrSort1(arr);
  14. //        ArrSort2(arr);
  15. //        ArrSort3(arr);
  16. //        ArrSort4(arr);
  17. //        ArrSort5(arr);
  18.  
  19.         //方法二：冒泡方法
  20. //        ArrSortM(arr);
  21. //        ArrSortM1(arr);
  22. //        ArrSortM2(arr);
  23. //        ArrSortM3(arr);
  24.  
  25.         //方法三：选择排序
  26. //        ArrSortX(arr);
  27. //        ArrSortX1(arr);
  28.  
  29.         //方法四：插入排序
  30. //        ArrSortC(arr);
  31.  
  32.         //方法五：快速排序
  33. //        ArrSortK(arr,0,arr.length-1);
  34.  
  35.          //方法六：归并排序
  36. //        ArrSortG(arr,0,arr.length-1);
  37.  
  38.     }
  39.  
  40.     private static void ArrSortG(int[] arr, int low, int high) {
  41.         if (low < high) {
  42.             int mid = (low + high) / 2;
  43.             ArrSortG(arr, low, mid);
  44.             ArrSortG(arr, mid + 1, high);
  45.             merge(arr, low, mid, high);
  46.         }
  47.         System.out.println("归并排序:"+Arrays.toString(arr));
  48.     }
  49.     private static void merge(int[] array, int low, int mid, int high) {
  50.         int[] temp = new int[high - low + 1];
  51.         int i = low;
  52.         int j = mid + 1;
  53.         int k = 0;
  54.         while (i <= mid && j <= high) {
  55.             if (array[i] <= array[j]) {
  56.                 temp[k++] = array[i++];
  57.             } else {
  58.                 temp[k++] = array[j++];
  59.             }
  60.         }
  61.         while (i <= mid) {
  62.             temp[k++] = array[i++];
  63.         }
  64.         while (j <= high) {
  65.             temp[k++] = array[j++];
  66.         }
  67.         for (int m = 0; m < temp.length; m++) {
  68.             array[low + m] = temp[m];
  69.         }
  70.     }
  71.  
  72.     private static void ArrSortK(int[] arr, int low, int high) {
  73.         if (low < high) {
  74.             int pivotIndex = partition(arr, low, high);
  75.             ArrSortK(arr, low, pivotIndex - 1);
  76.             ArrSortK(arr, pivotIndex + 1, high);
  77.         }
  78.         System.out.println("快速排序:"+Arrays.toString(arr));
  79.     }
  80.  
  81.     private static int partition(int[] arr, int low, int high) {
  82.         int pivot = arr[high];
  83.         int i = low - 1;
  84.         for (int j = low; j < high; j++) {
  85.             if (arr[j] < pivot) {
  86.                 i++;
  87.                 int temp = arr[i];
  88.                 arr[i] = arr[j];
  89.                 arr[j] = temp;
  90.             }
  91.         }
  92.         int temp = arr[i + 1];
  93.         arr[i + 1] = arr[high];
  94.         arr[high] = temp;
  95.         return i + 1;
  96.     }
  97.  
  98.     private static void ArrSortC(int[] arr) {
  99.         for (int i = 1; i < arr.length; i++) {
  100.             int key = arr[i];
  101.             int j = i - 1;
  102.             while (j >= 0 && arr[j] > key) {
  103.                 arr[j + 1] = arr[j];
  104.                 j--;
  105.             }
  106.             arr[j + 1] = key;
  107.         }
  108.     }
  109.  
  110.     private static void ArrSortX(int[] arr) {
  111.         for (int i = 0; i < arr.length - 1; i++) {
  112.             int minIndex = i;
  113.             for (int j = i + 1; j < arr.length; j++) {
  114.                 if (arr[j] < arr[minIndex]) {
  115.                     minIndex = j;
  116.                 }
  117.             }
  118.             int temp = arr[i];
  119.             arr[i] = arr[minIndex];
  120.             arr[minIndex] = temp;
  121.         }
  122.         System.out.println("选择排序:"+ Arrays.toString(arr));
  123.     }
  124.     private static void ArrSortX1(int[] arr) {
  125.         int minIndex, maxIndex;
  126.         // i 只需要遍历一半
  127.         for (int i = 0; i < arr.length / 2; i++) {
  128.             minIndex = i;
  129.             maxIndex = i;
  130.             for (int j = i + 1; j < arr.length - i; j++) {
  131.                 if (arr[minIndex] > arr[j]) {
  132.                     // 记录最小值的下标
  133.                     minIndex = j;
  134.                 }
  135.                 if (arr[maxIndex] < arr[j]) {
  136.                     // 记录最大值的下标
  137.                     maxIndex = j;
  138.                 }
  139.             }
  140.             // 将最小元素交换至首位
  141.             int temp = arr[i];
  142.             arr[i] = arr[minIndex];
  143.             arr[minIndex] = temp;
  144.             // 如果最大值的下标刚好是 i，由于 arr[i] 和 arr[minIndex] 已经交换了，所以这里要更新 maxIndex 的值。
  145.             if (maxIndex == i) maxIndex = minIndex;
  146.             // 将最大元素交换至末尾
  147.             int lastIndex = arr.length - 1 - i;
  148.             temp = arr[lastIndex];
  149.             arr[lastIndex] = arr[maxIndex];
  150.             arr[maxIndex] = temp;
  151.         }
  152.         System.out.println("选择排序1:"+ Arrays.toString(arr));
  153.     }
  154.  
  155.     private static void ArrSortM(int[] arr) {
  156.         for (int i = 0; i < arr.length - 1; i++) {
  157.             for (int j = 0; j < arr.length - 1 - i; j++) {
  158.                 // 升序：如果左边的数大于右边的数，则交换，保证右边的数字最大
  159.                 // 降序：如果左边的数小于右边的数，则交换，保证右边的数字最小
  160.                 if (arr[j] > arr[j + 1]) {
  161.                     int temp = arr[j];
  162.                     arr[j] = arr[j + 1];
  163.                     arr[j + 1] = temp;
  164.                 }
  165.             }
  166.         }
  167.         System.out.println("冒泡排序:"+Arrays.toString(arr));
  168.     }
  169.     private static void ArrSortM1(int[] arr) {
  170.         // 初始时 swapped 为 true，否则排序过程无法启动
  171.         boolean swapped = true;
  172.         for (int i = 0; i < arr.length - 1; i++) {
  173.             // 如果没有发生过交换，说明剩余部分已经有序，排序完成
  174.             if (!swapped) break;
  175.             // 设置 swapped 为 false，如果发生交换，则将其置为 true
  176.             swapped = false;
  177.             for (int j = 0; j < arr.length - 1 - i; j++) {
  178.                 if (arr[j] > arr[j + 1]) {
  179.                     // 如果左边的数大于右边的数，则交换，保证右边的数字最大
  180.                     int temp = arr[j];
  181.                     arr[j] = arr[j + 1];
  182.                     arr[j + 1] = temp;
  183.                     // 表示发生了交换
  184.                     swapped = true;
  185.                 }
  186.             }
  187.         }
  188.         System.out.println("冒泡排序1:"+Arrays.toString(arr));
  189.     }
  190.  
  191.     private static void ArrSortM2(int[] arr) {
  192.         for (int i = 0; i < arr.length - 1; i++) {
  193.             for (int j = 0; j < arr.length - 1 - i; j++) {
  194.                 // 不添加参数的写法
  195.                 // 升序：如果左边的数大于右边的数，则交换，保证右边的数字最大
  196.                 // 降序：如果左边的数小于右边的数，则交换，保证右边的数字最小
  197.                 if (arr[j] > arr[j + 1]) {
  198.                     arr[j + 1] = arr[j + 1] + arr[j];
  199.                     arr[j] = arr[j + 1] - arr[j];
  200.                     arr[j + 1] = arr[j + 1] - arr[j];
  201.                 }
  202.             }
  203.         }
  204.         System.out.println("冒泡排序2:"+Arrays.toString(arr));
  205.     }
  206.     private static void ArrSortM3(int[] arr) {
  207.         boolean swapped = true;
  208.         // 最后一个没有经过排序的元素的下标
  209.         int indexOfLastUnsortedElement = arr.length - 1;
  210.         // 上次发生交换的位置
  211.         int swappedIndex = -1;
  212.         while (swapped) {
  213.             swapped = false;
  214.             for (int i = 0; i < indexOfLastUnsortedElement; i++) {
  215.                 if (arr[i] > arr[i + 1]) {
  216.                     // 如果左边的数大于右边的数，则交换，保证右边的数字最大
  217.                     int temp = arr[i];
  218.                     arr[i] = arr[i + 1];
  219.                     arr[i + 1] = temp;
  220.                     // 表示发生了交换
  221.                     swapped = true;
  222.                     // 更新交换的位置
  223.                     swappedIndex = i;
  224.                 }
  225.             }
  226.             // 最后一个没有经过排序的元素的下标就是最后一次发生交换的位置
  227.             indexOfLastUnsortedElement = swappedIndex;
  228.         }
  229.         System.out.println("冒泡排序3:"+Arrays.toString(arr));
  230.     }
  231.  
  232.     private static void ArrSort1(int[] arr) {
  233.         Arrays.sort(arr);
  234.         System.out.println("快速排序-默认升序:"+Arrays.toString(arr));
  235.     }
  236.     private static void ArrSort2(int[] arr) {
  237.         //数组类型不能是基本数据类型
  238.         Integer[] arrayInteger = Arrays.stream(arr).boxed().toArray(Integer[]::new);
  239.         Arrays.sort(arrayInteger, Collections.reverseOrder());
  240.         System.out.println("快速排序-降序:"+Arrays.toString(arrayInteger));
  241.     }
  242.     private static void ArrSort3(int[] arr) {
  243.         Arrays.sort(arr,1, 3);
  244.         System.out.println("快速排序-区间排序:"+Arrays.toString(arr));
  245.     }
  246.     private static void ArrSort4(int[] arr) {
  247.         Integer[] arrayInteger = Arrays.stream(arr).boxed().toArray(Integer[]::new);
  248.         Arrays.sort(arrayInteger, new Comparator<Integer>() {
  249.             @Override
  250.             public int compare(Integer o1, Integer o2) {
  251.                 return o2 - o1;
  252.             }
  253.         });
  254.         System.out.println("快速排序-重载排序:"+Arrays.toString(arrayInteger));
  255.     }
  256.     private static void ArrSort5(int[] arr) {
  257.         Integer[] arrayInteger = Arrays.stream(arr).boxed().toArray(Integer[]::new);
  258.         //lambda表达式
  259.         Arrays.sort(arrayInteger, (o1, o2) -> o2 - o1);
  260.         System.out.println("快速排序-重载排序:"+Arrays.toString(arrayInteger));
  261.     }
  262.  
  263.     private static void extracted(int[] arr) {
  264.         System.out.println("原来的数组:"+ arr);
  265.         //输出方式-for
  266.         System.out.println("输出方式-for:");
  267.         for (int i = 0; i < arr.length; i++) {
  268.             System.out.println("for循环输出:"+ arr[i]);
  269.         }
  270.         System.out.println("======================");
  271.         //输出方式-for each
  272.         System.out.println("输出方式-for each:");
  273.         for (int i: arr){
  274.             System.out.println("for each循环输出:"+i);
  275.         }
  276.         System.out.println("======================");
  277.         //输出方式1-toString
  278.         System.out.println("输出方式-toString:");
  279.         System.out.println("toString:"+Arrays.toString(arr));
  280.         System.out.println("======================");
  281.     }
  282.  
  283. }
声明：本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号