有一个int[]，数组内有一定数量的元素，将该数组内元素按逆序排序，解析所使用方案的优缺点。假定数组int[] arrs={5,1,6,3,4,9,22,65,77}。
2.思路2.1 方案一
利用Arrays.sort()方法默认升序排序，升序排序完成后，依次交换int[i]，int[arrs.length -1-i]位置上的元素，即可获得新数组。代码如下：
long startTime = System.currentTimeMillis();
Arrays.sort(arrs);
System.out.println(Arrays.toString(arrs));
for (int min = 0, max = arrs.length - 1; min < max; min++, max--) {
int temp = arrs[min];
arrs[min] = arrs[max];
arrs[max] = temp;
}
long endTime = System.currentTimeMillis();
System.out.println(Arrays.toString(arrs));
System.out.println("耗时:" + (endTime - startTime));
运行结果如下：
2.2 方案二
采用冒泡排序的思想，每次取出数组中元素最小的值。代码如下：
System.out.println(Arrays.toString(arrs));
long startTime = System.currentTimeMillis();
for (int i = 0; i < arrs.length; i++) {
for (int j = arrs.length - 1; j > i; j--) {
int temp = arrs[i];
if (arrs[i] < arrs[j]) {
arrs[i] = arrs[j];
arrs[j] = temp;
}
}
}
long endTime = System.currentTimeMillis();
System.out.println(Arrays.toString(arrs));
System.out.println("耗时:" + (endTime - startTime));
运行结果如下：
2.3 方案三
先调用Arrays.sort()方法将数组排序，再创建一个新数组nums[]，将arrs[arrs.length -i-1]的值赋值给nums[i]，本质还是冒泡排序算法。
long startTime = System.currentTimeMillis();
int[] nums = new int[arrs.length];
System.out.println(Arrays.toString(arrs));
Arrays.sort(arrs);
for (int i = 0; i < arrs.length; i++) {
nums[i] = arrs[arrs.length -i-1];
}
long endTime = System.currentTimeMillis();
System.out.println(Arrays.toString(nums));
System.out.println("耗时:" + (endTime - startTime));
运行结果如下：
2.4 方案四
利用Arrays.sort()方法中自定义排序规则，由于int[]是原子类型数组，首先需转成对象类数组，具体实现方案如下：
long startTime = System.currentTimeMillis();
Integer[] nums = new Integer[arrs.length];
for (int i = 0; i < arrs.length; i++) {
nums[i] = arrs[i];
}
System.out.println(Arrays.toString(nums));
Arrays.sort(nums, new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o2-o1;
}
});
long endTime = System.currentTimeMillis();
System.out.println(Arrays.toString(nums));
System.out.println("耗时:" + (endTime - startTime));
运行结果如下：
2.5 方案五
利用lambda表达式先将原子类型数组转换为包装类型数组，再自定义new Comparator逆序排序。本质与方案四相同，具体实现方案如下：
long startTime = System.currentTimeMillis();
System.out.println(Arrays.toString(arrs));
arrs = Arrays.stream(arrs).boxed().sorted(((o1, o2) -> o2 - o1)).mapToInt(int1 -> int1).toArray();
System.out.println(Arrays.toString(arrs));
long endTime = System.currentTimeMillis();
System.out.println("耗时:" + (endTime - startTime));
运行结果如下：
1.这个问题的本质是如何将JAVA中int原子类型的数组内元素进行排序，由于Arrays类提供对包装类数组排序的自定义方法，因此可以借助Arrays类，前提是需要将int原子类型数组转换为Integer[]类型；
2.方案二与方案一原理一致，但从代码的优雅程度来说，方案一会明显优于方案二，且方案一的时间复杂度为O(n)，方案二的时间复杂度为O(n*n)，在数据量够大的情况下，方案一的运行速度会明显优于方案二；
3.方案四与方案五本质一致，实现方式不同，若数据量足够大，方案五的运行速度会远胜于方案四；方案四的空间复杂度为O(n)，牺牲了大量空间；
4.本文上述实现方案运行耗时取得是多次运算后最接近平均值的时间（运行内存：8G，处理器：AMD Ryzen 7 3700u with Radeon Vega Mobile Gfx2.30 GHz）。
