Java排序方法记录

## 简介

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

<!-- more -->

## 包装类型

### 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]);
```