简介

本文用于记录Java语言常用的一些排序方法，主要为Java原生方法。

包装类型

List

• 正序

java
// 用户实体List
List<User> list;
// 按照 userId 正序排序
list.sort(Comparator.comparing(Incident::getUserId));

• 倒叙

java
// 用户实体List
List<User> list;
// 按照 userId 倒叙排序
list.sort(Comparator.comparing(Incident::getUserId).reversed());

基础类型

Integer

以下示例均以 Integer 演示，其他类型数字不再提供示例。

正序

• 正序1：Collections

java
// 年份数字集合
List<Integer> years;
// 1
Collections.sort(years);

• 正序2：JDK8

java
// 年份数字集合
List<Integer> years;
// 2
list.sort(Comparator.naturalOrder());

• 正序3：Stream API（java8）

java
// 年份数字集合
List<Integer> years;
// 3
list = list.stream()
           .sorted()
           .collect(Collectors.toList());

• 正序4：JDK8-特定类型

java
// 年份数字集合
List<Integer> years;
// 4 Integer类型示例
list.sort(Comparator.comparingInt(o -> o));

• 正序5：JDK8：自定义

java
// 年份数字集合
List<Integer> years;
// 5： i1-i2 > 0则交换位置，所以是正序
list.sort((i1, i2) -> i1 - i2);

• 正序6：冒泡排序

java
List<Integer> years;
int n = years.length;

/** 冒泡正序排序 **/

// 外层循环控制比较的轮数
for (int i = 0; i < n - 1; i++) {
    // 内层循环进行相邻元素的比较和交换
    for (int j = 0; j < n - i - 1; j++) {
        if (years[j] > years[j + 1]) {
            // 交换相邻元素
            int temp = years[j];
            years[j] = years[j + 1];
            years[j + 1] = temp;
        }
    }
}

倒叙

倒叙只给出一个示例，其他参考正序做修改即可。

java
// 年份数字集合
List<Integer> years;
// 倒叙排序
years.sort(Collections.reverseOrder());

String

String 类型正常排序与 Integer 没有什么大区别，参考修改即可，下面给出一些特殊需求排序：

长度排序

java
List<String> list;
list.sort(Comparator.comparing(String::length));

复杂中文排序

普通中文与普通字符串排序一样，一些特殊中文、字符可能用得到该方法

java
List<String> chineseList = Arrays.asList("张三", "李四", "王五", "赵六");

// 使用 Collator 进行排序，特殊使用请自行摸索
Collator collator = Collator.getInstance();
Collections.sort(chineseList, collator);

数组

正序

• 方式1

java
Integer[] array = {64, 34, 25, 12, 22, 11, 90};
Arrays.sort(array);

• 方式2：冒泡

java
Integer[] array = {64, 34, 25, 12, 22, 11, 90};
int n = array.length;

// 外层循环控制比较的轮数
for (int i = 0; i < n - 1; i++) {
    // 内层循环进行相邻元素的比较和交换
    for (int j = 0; j < n - i - 1; j++) {
        if (array[j] > array[j + 1]) {
            // 交换相邻元素
            int temp = array[j];
            array[j] = array[j + 1];
            array[j + 1] = temp;
        }
    }
}

倒叙

• 方式1

java
Integer[] array = {64, 34, 25, 12, 22, 11, 90};
Arrays.sort(array, Collections.reverseOrder());

• 方式2：冒泡

java
Integer[] array = {64, 34, 25, 12, 22, 11, 90};
int n = array.length;

// 外层循环控制比较的轮数
for (int i = 0; i < n - 1; i++) {
    // 内层循环进行相邻元素的比较和交换
    for (int j = 0; j < n - i - 1; j++) {
        if (array[j] < array[j + 1]) {
            // 交换相邻元素
            int temp = array[j];
            array[j] = array[j + 1];
            array[j + 1] = temp;
        }
    }
}

拓展

数组与List互相转换

java
Integer[] array = {64, 34, 25, 12, 22, 11, 90};
// 数组转List
List<Integer> list = Arrays.asList(array);
// List转数组
array = list.toArray(new Integer[0]);