第2章 Java编程基础——FAQ2.27 数组的排序算法有哪些？如何实现？

FAQ2.27 数组的排序算法有哪些？如何实现？

答：

import java.util.Random;

/**
* 排序测试类
*
* 排序算法的分类如下：
* 1.插入排序（直接插入排序、折半插入排序、希尔排序）；
* 2.交换排序（冒泡泡排序、快速排序）；
* 3.选择排序（直接选择排序、堆排序）；
* 4.归并排序；
* 5.基数排序。
*
* 关于排序方法的选择：
* (1)若n较小(如n≤50)，可采用直接插入或直接选择排序。
* 当记录规模较小时，直接插入排序较好；否则因为直接选择移动的记录数少于直接插人，应选直接选择排序为宜。
* (2)若文件初始状态基本有序(指正序)，则应选用直接插人、冒泡或随机的快速排序为宜；
* (3)若n较大，则应采用时间复杂度为O(nlgn)的排序方法：快速排序、堆排序或归并排序。
*
* @author WangRuifeng
*/
public class SortTest {

/**
* 初始化测试数组的方法
* @return 一个初始化好的数组
*/
public int[] createArray() {
Random random = new Random();
int[] array = new int[10];
for (int i = 0; i < 10; i++) {
array[i] = random.nextInt(100) - random.nextInt(100);//生成两个随机数相减，保证生成的数中有负数
}
System.out.println("==========原始序列==========");
printArray(array);
return array;
}

/**
* 打印数组中的元素到控制台
* @param source
*/
public void printArray(int[] source) {
for (int i : source) {
System.out.print(i + " ");
}
System.out.println();
}

/**
* 交换数组中指定的两元素的位置
* @param source
* @param x
* @param y
*/
private void swap(int[] source, int x, int y) {
int temp = source[x];
source[x] = source[y];
source[y] = temp;
}

/**
* 冒泡排序----交换排序的一种
* 方法：相邻两元素进行比较，如有需要则进行交换，每完成一次循环就将最大元素排在最后（如从小到大排序），下一次循环是将其他的数进行类似操作。
* 性能：比较次数O(n^2),n^2/2；交换次数O(n^2),n^2/4
*
* @param source 要排序的数组
* @param sortType 排序类型
* @return
*/
public void bubbleSort(int[] source, String sortType) {
if (sortType.equals("asc")) { //正排序，从小排到大
for (int i = source.length - 1; i > 0; i--) {
for (int j = 0; j < i; j++) {
if (source[j] > source[j + 1]) {
swap(source, j, j + 1);
}
}
}
} else if (sortType.equals("desc")) { //倒排序，从大排到小
for (int i = source.length - 1; i > 0; i--) {
for (int j = 0; j < i; j++) {
if (source[j] < source[j + 1]) {
swap(source, j, j + 1);
}
}
}
} else {
System.out.println("您输入的排序类型错误！");
}
printArray(source);//输出冒泡排序后的数组值
}

/**
* 直接选择排序法----选择排序的一种
* 方法：每一趟从待排序的数据元素中选出最小（或最大）的一个元素， 顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。
* 性能：比较次数O(n^2),n^2/2
* 交换次数O(n),n
* 交换次数比冒泡排序少多了，由于交换所需CPU时间比比较所需的CUP时间多，所以选择排序比冒泡排序快。
* 但是N比较大时，比较所需的CPU时间占主要地位，所以这时的性能和冒泡排序差不太多，但毫无疑问肯定要快些。
*
* @param source 要排序的数组
* @param sortType 排序类型
* @return
*/
public void selectSort(int[] source, String sortType) {

if (sortType.equals("asc")) { //正排序，从小排到大
for (int i = 0; i < source.length; i++) {
for (int j = i + 1; j < source.length; j++) {
if (source[i] > source[j]) {
swap(source, i, j);
}
}
}
} else if (sortType.equals("desc")) { //倒排序，从大排到小
for (int i = 0; i < source.length; i++) {
for (int j = i + 1; j < source.length; j++) {
if (source[i] < source[j]) {
swap(source, i, j);
}
}
}
} else {
System.out.println("您输入的排序类型错误！");
}
printArray(source);//输出直接选择排序后的数组值
}

/**
* 插入排序
* 方法：将一个记录插入到已排好序的有序表（有可能是空表）中,从而得到一个新的记录数增1的有序表。
* 性能：比较次数O(n^2),n^2/4
* 复制次数O(n),n^2/4
* 比较次数是前两者的一般，而复制所需的CPU时间较交换少，所以性能上比冒泡排序提高一倍多，而比选择排序也要快。
*
* @param source 要排序的数组
* @param sortType 排序类型
*/
public void insertSort(int[] source, String sortType) {
if (sortType.equals("asc")) { //正排序，从小排到大
for (int i = 1; i < source.length; i++) {
for (int j = i; (j > 0) && (source[j] < source[j - 1]); j--) {
swap(source, j, j - 1);
}
}
} else if (sortType.equals("desc")) { //倒排序，从大排到小
for (int i = 1; i < source.length; i++) {
for (int j = i; (j > 0) && (source[j] > source[j - 1]); j--) {
swap(source, j, j - 1);
}
}
} else {
System.out.println("您输入的排序类型错误！");
}
printArray(source);//输出插入排序后的数组值
}

/**
* 反转数组的方法
* @param source 源数组
*/
public void reverse(int[] source) {

int length = source.length;
int temp = 0;//临时变量

for (int i = 0; i < length / 2; i++) {
temp = source[i];
source[i] = source[length - 1 - i];
source[length - 1 - i] = temp;
}
printArray(source);//输出到转后数组的值
}

/**
* 快速排序
* 快速排序使用分治法（Divide and conquer）策略来把一个序列（list）分为两个子序列（sub-lists）。
* 步骤为：
* 1. 从数列中挑出一个元素，称为 "基准"（pivot），
* 2. 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分割之后，该基准是它的最后位置。这个称为分割（partition）操作。
* 3. 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
* 递回的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递回下去，但是这个算法总会结束，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。
* @param source 待排序的数组
* @param low
* @param high
* @see SortTest#qsort(int[], int, int)
* @see SortTest#qsort_desc(int[], int, int)
*/
public void quickSort(int[] source, String sortType) {
if (sortType.equals("asc")) { //正排序，从小排到大
qsort_asc(source, 0, source.length - 1);
} else if (sortType.equals("desc")) { //倒排序，从大排到小
qsort_desc(source, 0, source.length - 1);
} else {
System.out.println("您输入的排序类型错误！");
}
}

/**
* 快速排序的具体实现，排正序
* @param source
* @param low
* @param high
*/
private void qsort_asc(int source[], int low, int high) {
int i, j, x;
if (low < high) { //这个条件用来结束递归
i = low;
j = high;
x = source[i];
while (i < j) {
while (i < j && source[j] > x) {
j--; //从右向左找第一个小于x的数
}
if (i < j) {
source[i] = source[j];
i++;
}
while (i < j && source[i] < x) {
i++; //从左向右找第一个大于x的数
}
if (i < j) {
source[j] = source[i];
j--;
}
}
source[i] = x;
qsort_asc(source, low, i - 1);
qsort_asc(source, i + 1, high);
}
}

/**
* 快速排序的具体实现，排倒序
* @param source
* @param low
* @param high
*/
private void qsort_desc(int source[], int low, int high) {
int i, j, x;
if (low < high) { //这个条件用来结束递归
i = low;
j = high;
x = source[i];
while (i < j) {
while (i < j && source[j] < x) {
j--; //从右向左找第一个小于x的数
}
if (i < j) {
source[i] = source[j];
i++;
}
while (i < j && source[i] > x) {
i++; //从左向右找第一个大于x的数
}
if (i < j) {
source[j] = source[i];
j--;
}
}
source[i] = x;
qsort_desc(source, low, i - 1);
qsort_desc(source, i + 1, high);
}
}

/**
* 二分法查找
* 查找线性表必须是有序列表
*
* @param source
* @param key
* @return
*/
public int binarySearch(int[] source, int key) {
int low = 0, high = source.length - 1, mid;
while (low <= high) {
mid = (low + high) >>> 1; //相当于mid = (low + high) / 2，但是效率会高些
if (key == source[mid]) {
return mid;
} else if (key < source[mid]) {
high = mid - 1;
} else {
low = mid + 1;
}
}
return -1;
}

public static void main(String[] args) {
SortTest sortTest = new SortTest();

int[] array = sortTest.createArray();

System.out.println("==========冒泡排序后(正序)==========");
sortTest.bubbleSort(array, "asc");
System.out.println("==========冒泡排序后(倒序)==========");
sortTest.bubbleSort(array, "desc");

array = sortTest.createArray();

System.out.println("==========倒转数组后==========");
sortTest.reverse(array);

array = sortTest.createArray();

System.out.println("==========选择排序后(正序)==========");
sortTest.selectSort(array, "asc");
System.out.println("==========选择排序后(倒序)==========");
sortTest.selectSort(array, "desc");

array = sortTest.createArray();

System.out.println("==========插入排序后(正序)==========");
sortTest.insertSort(array, "asc");
System.out.println("==========插入排序后(倒序)==========");
sortTest.insertSort(array, "desc");

array = sortTest.createArray();
System.out.println("==========快速排序后(正序)==========");
sortTest.quickSort(array, "asc");
sortTest.printArray(array);
System.out.println("==========快速排序后(倒序)==========");
sortTest.quickSort(array, "desc");
sortTest.printArray(array);

System.out.println("==========数组二分查找==========");
System.out.println("您要找的数在第" + sortTest.binarySearch(array, 74) + "个位子。（下标从0计算）");
}
}

字符串排序：

public class StringSort {
public static void main(String []args) {
String[] s={"a","b","c","d","m","f"};
for(int i=s.length-1;i>=1;i--){
for(int j=0;j<=i-1;j++) {
if(s[j].compareTo(s[j+1])<0) {
String temp=null;
temp=s[j];
s[j]=s[j+1];
s[j+1]=temp;
}
}
}
for(String a:s){
System.out.print(a+" ");
}
}
}
比较字符串的实质是比较字符串的字母，首字母相同，比较下一个，然后又相同的话，再下一个....所以你可以先用substring();截出第一个字符，然后再比较，相同的再截第二个，.....

————————————————————————————————————————————————————————————————————————————————————————

为了便于管理，先引入个基础类：

package algorithms;

/**
* @author yovn
*
*/
public abstract class Sorter < E extends Comparable < E >> {
public abstract void sort(E[] array, int from , int len);
public final void sort(E[] array)
{
sort(array, 0 ,array.length);
}
protected final void swap(E[] array, int from , int to)
{
E tmp = array[from];
array[from] = array[to];
array[to] = tmp;
}

}
一 插入排序
该算法在数据规模小的时候十分高效，该算法每次插入第K+1到前K个有序数组中一个合适位置，K从0开始到N-1,从而完成排序：

package algorithms;
/**
* @author yovn
*/
public class InsertSorter < E extends Comparable < E >> extends Sorter < E > {

/* (non-Javadoc)
* @see algorithms.Sorter#sort(E[], int, int)
*/
public void sort(E[] array, int from, int len) {
E tmp = null ;
for ( int i = from + 1 ;i < from + len;i ++ )
{
tmp = array[i];
int j = i;
for (;j > from;j -- )
{
if (tmp.compareTo(array[j - 1 ]) < 0 )
{
array[j] = array[j - 1 ];
}
else break ;
}
array[j] = tmp;
}
}

}

二 冒泡排序
这可能是最简单的排序算法了，算法思想是每次从数组末端开始比较相邻两元素，把第i小的冒泡到数组的第i个位置。i从0一直到N-1从而完成排序。（当然也可以从数组开始端开始比较相邻两元素，把第i大的冒泡到数组的第N-i个位置。i从0一直到N-1从而完成排序。)

package algorithms;

/**
* @author yovn
*
*/
public class BubbleSorter < E extends Comparable < E >> extends Sorter < E > {

private static boolean DWON = true ;
public final void bubble_down(E[] array, int from, int len)
{
for ( int i = from;i < from + len;i ++ )
{
for ( int j = from + len - 1 ;j > i;j -- )
{
if (array[j].compareTo(array[j - 1 ]) < 0 )
{
swap(array,j - 1 ,j);
}
}
}
}
public final void bubble_up(E[] array, int from, int len)
{
for ( int i = from + len - 1 ;i >= from;i -- )
{
for ( int j = from;j < i;j ++ )
{
if (array[j].compareTo(array[j + 1 ]) > 0 )
{
swap(array,j,j + 1 );
}
}
}
}
@Override
public void sort(E[] array, int from, int len) {
if (DWON)
{
bubble_down(array,from,len);
}
else
{
bubble_up(array,from,len);
}
}
}

三，选择排序
选择排序相对于冒泡来说，它不是每次发现逆序都交换，而是在找到全局第i小的时候记下该元素位置，最后跟第i个元素交换，从而保证数组最终的有序。
相对与插入排序来说，选择排序每次选出的都是全局第i小的，不会调整前i个元素了。

package algorithms;
/**
* @author yovn
*
*/
public class SelectSorter < E extends Comparable < E >> extends Sorter < E > {

/* (non-Javadoc)
* @see algorithms.Sorter#sort(E[], int, int)
*/
@Override
public void sort(E[] array, int from, int len) {
for ( int i = 0 ;i < len;i ++ )
{
int smallest = i;
int j = i + from;
for (;j < from + len;j ++ )
{
if (array[j].compareTo(array[smallest]) < 0 )
{
smallest = j;
}
}
swap(array,i,smallest);
}

}
}

四 Shell排序
Shell排序可以理解为插入排序的变种，它充分利用了插入排序的两个特点：
1）当数据规模小的时候非常高效
2）当给定数据已经有序时的时间代价为O(N)
所以，Shell排序每次把数据分成若个小块，来使用插入排序，而且之后在这若个小块排好序的情况下把它们合成大一点的小块，继续使用插入排序，不停的合并小块，知道最后成一个块，并使用插入排序。

这里每次分成若干小块是通过“增量” 来控制的，开始时增量交大，接近N/2,从而使得分割出来接近N/2个小块，逐渐的减小“增量“最终到减小到1。

一直较好的增量序列是2^k-1,2^(k-1)-1,.....7,3,1,这样可使Shell排序时间复杂度达到O(N^1.5)
所以我在实现Shell排序的时候采用该增量序列

package algorithms;

/**
* @author yovn
*/
public class ShellSorter < E extends Comparable < E >> extends Sorter < E > {

/* (non-Javadoc)
* Our delta value choose 2^k-1,2^(k-1)-1, .7,3,1.
* complexity is O(n^1.5)
* @see algorithms.Sorter#sort(E[], int, int)
*/
@Override
public void sort(E[] array, int from, int len) {
// 1.calculate the first delta value;
int value = 1 ;
while ((value + 1 ) * 2 < len)
{
value = (value + 1 ) * 2 - 1 ;
}
for ( int delta = value;delta >= 1 ;delta = (delta + 1 ) / 2 - 1 )
{
for ( int i = 0 ;i < delta;i ++ )
{
modify_insert_sort(array,from + i,len - i,delta);
}
}

}
private final void modify_insert_sort(E[] array, int from, int len, int delta) {
if (len <= 1 ) return ;
E tmp = null ;
for ( int i = from + delta;i < from + len;i += delta)
{
tmp = array[i];
int j = i;
for (;j > from;j -= delta)
{
if (tmp.compareTo(array[j - delta]) < 0 )
{
array[j] = array[j - delta];
}
else break ;
}
array[j] = tmp;
}

}
}

五 快速排序
快速排序是目前使用可能最广泛的排序算法了。
一般分如下步骤：
1）选择一个枢纽元素（有很对选法，我的实现里采用去中间元素的简单方法）
2）使用该枢纽元素分割数组，使得比该元素小的元素在它的左边，比它大的在右边。并把枢纽元素放在合适的位置。
3）根据枢纽元素最后确定的位置，把数组分成三部分，左边的，右边的，枢纽元素自己，对左边的，右边的分别递归调用快速排序算法即可。
快速排序的核心在于分割算法，也可以说是最有技巧的部分。

package algorithms;

/**
* @author yovn
*
*/
public class QuickSorter < E extends Comparable < E >> extends Sorter < E > {

/* (non-Javadoc)
* @see algorithms.Sorter#sort(E[], int, int)
*/
@Override
public void sort(E[] array, int from, int len) {
q_sort(array,from,from + len - 1 );
}

private final void q_sort(E[] array, int from, int to) {
if (to - from < 1 ) return ;
int pivot = selectPivot(array,from,to);

pivot = partion(array,from,to,pivot);
q_sort(array,from,pivot - 1 );
q_sort(array,pivot + 1 ,to);
}

private int partion(E[] array, int from, int to, int pivot) {
E tmp = array[pivot];
array[pivot] = array[to]; // now to's position is available
while (from != to)
{
while (from < to && array[from].compareTo(tmp) <= 0 )from ++ ;
if (from < to)
{
array[to] = array[from]; // now from's position is available
to -- ;
}
while (from < to && array[to].compareTo(tmp) >= 0 )to -- ;
if (from < to)
{
array[from] = array[to]; // now to's position is available now
from ++ ;
}
}
array[from] = tmp;
return from;
}

private int selectPivot(E[] array, int from, int to) {
return (from + to) / 2 ;
}

}

————————————————————————————————————————————————————————————————————————————————————————

import java.lang.Math;
import java.util.Random;
/**
* 排序
*
* @author javajack
*/
public class OrderTest {
public static void main(String args[]) {
OrderTest.ExecOrder(2);
}
/**
* 交换值，交换数组的两个值
* @param array
* @param i
* @param j
*/
private static void swap(int[] array,int i, int j)
{
int tmp = array[i];
array[i] = array[j];
array[j] = tmp;
}
/**
*
* @param method
* 1为升序，2为降序
*/
public static void ExecOrder(int method) {
int[] array = null;
array = initArray(10, 210, 10);
//int[] orderarray = bubbleOrder(array,method);
int[] orderarray = doubleBubbleOrder(array,method);
//int[] orderarray = insertOrder(array, method);
//int [] orderarray = quickOrder(array,method);
//int[] orderarray = selectOrder(array, method);
for (int i = 0; i < orderarray.length; i++) {
System.out.println(orderarray[i]);
}
}
/**
* 取随机数据，初始化一个数组
*
* @param min
* 随机数的最小值
* @param max
* 最大值
* @param size
* 取得随机数的数量
* @return
*/
public static int[] initArray(int min, int max, int size) {
int[] init = new int[size];
for (int i = 0; i < size; i++) {
Random ra = new Random();
init[i] = min + (int) (Math.random() * (max - min + 1));
System.out.println(i + "-------" + init[i]);
}
return init;
}
/**
* 交换排序方法
* 原理：依次交换值
* @param array
* @return
*/
public static int[] convertOrder(int[] array, int method) {
for (int i = 0; i < array.length; i++) {
for (int j = i + 1; j < array.length; j++)
{
if (method==2)
{
if (array[i] < array[j])
swap(array,i,j);
}else if (method == 1) {
if (array[i] > array[j])
swap(array,i,j);
}
}
}
return array;
}
/**冒泡排序方法
* 原理：从最后一个开始将小的或大的逐渐冒出
* @param array
* @param method
* @return
*/
public static int[] bubbleOrder(int[] array,int method)
{
for(int i=0;i<array.length;i++)
{
for (int j=array.length -1 ;j>i;j--)
{
if (method==2)
{
if (array[i] < array[j])
swap(array,i,j);
}else if (method==1)
if (array[i] > array[j])
swap(array,i,j);
}
}
return array;
}
/**
* 双向冒泡排序
* 原理：类似于冒泡排序，只不过是双向的
* @param array
* @param method
* @return
*/
public static int[] doubleBubbleOrder(int[] array,int method)
{
int left = 0;
int right = array.length -1 ;
while (left < right)
{
for(int i=left;i<=right;i++)
{
if (method==1)
{
if (array[left] > array[i])
swap(array,left,i);
}else
{
if (array[left] < array[i])
swap(array,left,i);
}
}
for (int i=left+1;i<=right;i++)
{
if (method==1)
{
if (array[right] < array[i])
swap(array,right,i);
}else
{
if (array[right] > array[i])
swap(array,right,i);
}
}
left++;
right--;
}
return array;
}
/**
* 快速排序方法，运用到递归
* 排序原理：随机找到一个值，然后以此值大小进行分为两个数组，大的放左边，小的放右边，
* 然后再对左右两侧的数据依次排序根据
* @param array
* @param method
* @return
*/
public static int[] quickOrder(int[] array, int method)
{
quickDeal(array,0,array.length - 1,method);
return array;
}
/**
*
* @param array
* @param begin
* 开始位置
* @param end
* 结束位置
*/
private static void quickDeal(int[] array, int begin, int end,int method) {
if (end > begin) {
int pos = begin + (int) (Math.random() * (end - begin + 1)); // 计算分隔位置
int posvalue = array[pos]; // 取得分隔位置的值
swap(array,pos,end); //将posvalue放到最end的位置
pos=begin; //初始化pos
for (int i=begin; i < end; i++) {
if (method==1)
{
if (array[i] < posvalue) { //当小于posvalue时，将此值移动到pos位置，也就是向前移动
swap(array,pos,i);
pos++; //移动后pos增1
}
}else if(method == 2)
{
if (array[i] > posvalue) { //当小于posvalue时，将此值移动到pos位置，也就是向前移动
swap(array,pos,i);
pos++; //移动后pos增1
}
}
}
swap(array,pos,end); //end位置的值前移
quickDeal(array,begin,pos -1,method);
quickDeal(array,pos+1,end,method);
}
}
/**
* 插入排序方法
* 排序原理：抽出一个数，做为排序基序列，然后依次抽出其它数与，与此序列中的数进行比较，放入合适的位置
* @param array
* @param method
* @return
*/
public static int[] insertOrder(int[] array, int method) {
for (int i = 1; i < array.length; i++) {
if (method == 1) {
if (array[i - 1] > array[i]) {
int tmp = array[i]; //
int j = i - 1;
do {
array[j + 1] = array[j];
j--;
} while (j >= 0 && tmp < array[j]); //当j>=0并且 当前值大于数据中j位置的值时移动
array[j + 1] = tmp; //插入排序值
}
} else if (method == 2) {
if (array[i - 1] < array[i]) {
int tmp = array[i];
int j = i - 1;
do {
array[j + 1] = array[j];
j--;
} while (j >= 0 && tmp > array[j]);
array[j + 1] = tmp;
}
}
}
return array;
}
/**
* 选择排序方法
* 排序原理：每次选择一个最大的或最小的数放到已排序序列中
* @param array
* @param method
* @return
*/
public static int[] selectOrder(int[] array,int method)
{
for (int i=0;i<array.length - 1;i++)
{
int tmp = array[i];
int pos = i+1; //记录大值或小值的位置
for (int j=i+1;j<array.length;j++)
{
if (method==1)
{
if (array[j]<tmp)
{
tmp = array[j];
pos= j ;//记录大值或小值的位置
}
}else if (method==2)
{
if (array[j]>tmp)
{
tmp = array[j];
pos= j ;//记录大值或小值的位置
}
}
}
if (tmp != array[i])
swap(array,i,pos); //不相同时交换
}
return array;
}
}

这个目的在于算法理解 ，而不在于java哈，而且Arrays。sort的底层实现，还不是用这些类似的代码实现的
java初学者最常见的错误思想，就是试图去写一些方法来完成数组的排序功能，其实，数组排序功能，在java的api里面早已实现，我们没有必要去重复制造轮子。
Arrays类有一个静态方法sort,利用这个方法我们可以传入我们要排序的数组进去排序，因为我们传入的是一个数组的引用，所以排序完成的结果也通过这个引用的来更改数组.
比如：
1. 数字排序
int[] intArray = new int[] {4, 1, 3, -23}; Arrays.sort(intArray);
输出： [-23, 1, 3, 4]
2. 字符串排序，先大写后小写
String[] strArray = new String[] {"z", "a", "C"};
Arrays.sort(strArray);
输出： [C, a, z]
3. 严格按字母表顺序排序，也就是忽略大小写排序
Case-insensitive sort
Arrays.sort(strArray, String.CASE_INSENSITIVE_ORDER);
输出： [a, C, z]
4. 反向排序，
Reverse-order sort
Arrays.sort(strArray, Collections.reverseOrder());
输出：[z, a, C]
5. 忽略大小写反向排序 Case-insensitive reverse-order sort
Arrays.sort(strArray, String.CASE_INSENSITIVE_ORDER);
Collections.reverse(Arrays.asList(strArray));
输出： [z, C, a]