//使用Arrays.sort()对字符串数组排序 String[] strArr = new String[]{"zhangsan","lisi","wangwu"}; Arrays.sort(strArr); System.out.println("默认按字母升序排序："); for (String str:strArr) { System.out.println(str); } //使用Collections.sort()对字符串集合排序 List<String> strList = new ArrayList<>(); strList.add("zhangsan"); strList.add("lisi"); strList.add("wangwu"); Collections.sort(strList); System.out.println("默认按字母升序排序："); for (String str:strList) { System.out.println(str); } 

复制

默认按字母升序排序：
lisi
wangwu
zhangsan
默认按字母升序排序：
lisi
wangwu
zhangsan

复制

//使用lambda表达式创建Comparator对象 Comparator<String> cmp = (s1, s2) -> s1.length() - s2.length(); //按照字符串长度升序排序 //使用匿名内部类创建Comparator对象 Comparator<String> cmp = new Comparator<String>() { @Override public int compare(String s1, String s2) { return s1.length() - s2.length(); //按照字符串长度升序排序 } }; //使用Arrays.sort()对字符串数组排序 String[] strArr = new String[]{"zhangsan","lisi","wangwu"}; Arrays.sort(strArr, cmp); //传入自定义的Comparator对象 System.out.println("自定义排序，按字符串长度升序排序："); for (String str:strArr) { System.out.println(str); } //使用Collections.sort()对字符串集合排序 List<String> strList = new ArrayList<>(); strList.add("zhangsan"); strList.add("lisi"); strList.add("wangwu"); Collections.sort(strList, cmp); //传入自定义的Comparator对象 System.out.println("自定义排序，按字符串长度升序排序："); for (String str:strList) { System.out.println(str); } 

复制

自定义排序，按字符串长度升序排序：
lisi
wangwu
zhangsan
自定义排序，按字符串长度升序排序：
lisi
wangwu
zhangsan

复制

class Student { String name; int key; //组号 public Student(String name, int key) { this.name = name; this.key = key; } public int key() { return key; } } public class KeyIndexSort { public static void sort(Student[] s, int R) { int N = s.length; int[] count = new int[R + 1]; Student[] aux = new Student[N]; //第一步：频率统计 for (int i = 0; i < N; i++) { count[s[i].key() + 1]++; } //第二步：频率转换为索引 for (int r = 0; r < R; r++) { count[r + 1] += count[r]; } //第三步：数据分类排序 for (int i = 0; i < N; i++) { aux[count[s[i].key()]++] = s[i]; } //第四步：回写排序好的数组 for (int i = 0; i < N; i++) { s[i] = aux[i]; } } public static void main(String[] args) { Student[] students = new Student[10]; students[0] = new Student("zhangsan", 2); students[1] = new Student("lisi", 1); students[2] = new Student("wangwu", 3); students[3] = new Student("zhaoliu", 2); students[4] = new Student("qianqi", 4); students[5] = new Student("sunba", 1); students[6] = new Student("zhoujiu", 3); students[7] = new Student("wushi", 4); students[8] = new Student("liushi", 2); students[9] = new Student("qishi", 1); sort(students, 5); //假设有5个组别 System.out.println("按照组号升序排序："); for (Student student:students) { System.out.println(student.name + " " + student.key); } } } 

复制

按照组号升序排序：
lisi 1
sunba 1
qishi 1
zhangsan 2
zhaoliu 2
liushi 2
wangwu 3
zhoujiu 3
qianqi 4
wushi 4

复制

public class LSDSort { public static void sort(String[] a, int W) { //通过前W个字符将a[]排序 int N = a.length; int R = 256; //基数，假设是扩展ASCII码 String[] aux = new String[N]; //辅助数组 for (int d = W - 1; d >= 0; d--) { //根据第d个字符用键索引计数法排序 int[] count = new int[R + 1]; //计算出现频率 for (int i = 0; i < N; i++) { count[a[i].charAt(d) + 1]++; } for (int r = 0; r < R; r++) { //将频率转换为索引 count[r + 1] += count[r]; } 

　　　　　　　　for (int i = 0; i < N; i++) { //将元素分类 aux[count[a[i].charAt(d)]++] = a[i];

   for (int i = 0; i < N; i++) { //回写 a[i] = aux[i]; } } } public static void main(String[] args) { String[] strArr = new String[]{"abc","def","ghi","jkl","mno","pqr","stu","vwx","yz"}; sort(strArr, 3); //假设字符串长度为3 System.out.println("按照字典顺序排序："); for (String str:strArr) { System.out.println(str); } } }

输出结果为：

按照字典顺序排序：
abc
def
ghi
jkl
mno
pqr
stu
vwx
yz

这就是低位优先的字符串排序的方法，它可以快速地对定长字符串进行排序，但是对于变长字符串或者不同长度的字符串，它就不适用了。下面我们来看另一种基于字符的排序方法，它可以处理变长字符串的情况。

5. 使用高位优先的字符串排序

高位优先的字符串排序是一种适用于变长字符串的排序方法，它从左到右以每个位置的字符作为键，用键索引计数法将字符串按首字母排序，然后递归地对每个首字母对应的子数组排序。这种方法和快速排序类似，都是通过切分和递归来完成排序任务，但是它的切分会为每个首字母得到一个子数组，而不是像快速排序中那样产生固定的两个或者三个切分。

假设我们有一个变长的字符串数组，我们想要按照字典顺序对它进行排序，可以使用以下代码：

public class MSDSort { //高位优先的字符串排序 private static int R = 256; //基数，假设是扩展ASCII码 private static final int M = 15; //小数组的切换阈值 private static String[] aux; //数组分类的辅助数组 private static int charAt(String s, int d) { //返回字符串s中第d个字符的索引，如果d超过了s的长度，返回-1 if (d < s.length()) { return s.charAt(d); } else { return -1; } } public static void sort(String[] a) { //对字符串数组a进行排序 int N = a.length; aux = new String[N]; sort(a, 0, N - 1, 0); //从第0个字符开始排序 } private static void sortInsert(String[] a, int lo, int hi) { //对小型数组进行插入排序 for (int i = lo + 1; i <= hi; i++) { for (int j = i; j > lo && a[j].compareTo(a[j - 1]) < 0; j--) { String tmp = a[j]; a[j] = a[j - 1]; a[j - 1] = tmp; } } } private static void sort(String[] a, int lo, int hi, int d) { //以第d个字符为键将a[lo]至a[hi]排序 if (hi <= lo + M) { //如果子数组较小，使用插入排序提高效率 sortInsert(a, lo, hi); return; } int[] count = new int[R + 2]; //计算频率 for (int i = lo; i <= hi; i++) { count[charAt(a[i], d) + 2]++; } for (int r = 0; r < R + 1; r++) { //将频率转换为索引 count[r + 1] += count[r];