在 Java 中，可以通过多种方式和库对数据进行排序。我所知道的JAVA排序有：

升序排序

使用stream：

List<Integer> list = Arrays.asList(5, 2, 8, 1, 3); 
List<Integer> sortedList = list.stream()
  	.sorted() 
    .collect(Collectors.toList()); 
System.out.println(sortedList); // [1, 2, 3, 5, 8]

或者使用java.util.Collections：

List<Integer> list = Arrays.asList(5, 2, 8, 1, 3); 
Collections.sort(list); 
System.out.println(list); // [1, 2, 3, 5, 8]

或者使用java.util.Arrays：

int[] array = {5, 2, 8, 1, 3}; 
Arrays.sort(array); 
System.out.println(Arrays.toString(array)); // [1, 2, 3, 5, 8]

降序排序

List<Integer> sortedList = list.stream() 
   .sorted(Comparator.reverseOrder()) 
   .collect(Collectors.toList()); 
System.out.println(sortedList); // [8, 5, 3, 2, 1]

或者使用lamda表达来生成一个降序排列的自定义compator

List<Integer> sortedList = list.stream()
    .sorted((a,b) -> b - a)
    .collect(Collectors.toList());
System.out.println(sortedList); //[8, 5, 3, 2, 1]

Parallel 排序（并行排序）

适用于较大的数据量，且对性能有要求的场景。

int[] array = {5, 2, 8, 1, 3}; 
Arrays.parallelSort(array); 
List<Integer> sortedList = Arrays.asList(array);
System.out.println(Arrays.toString(array)); 
System.out.println(sortedList); //[8, 5, 3, 2, 1]

随机排列

Collections.shuffle 用于对 列表（List）中的元素进行 随机排列，改变元素的顺序，使之成为一种 非确定性随机顺序。

import java.util.Collections; 

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5); 
Collections.shuffle(list); 
System.out.println(list); // 输出可能是 [3, 5, 1, 4, 2]，每次运行结果不同 

排序且去重

list.stream().distinct().sorted().collect(Collectors.toList());

字符串排序

按照字母排序：

String[] names = {"Charlie", "Alice", "Bob"}; 
Arrays.sort(names); // 按长度排序 
System.out.println(Arrays.toString(names)); // [Bob, Alice, Charlie]

按照字符串长度排序：

String[] names = {"Charlie", "Alice", "Bob"}; 
Arrays.sort(names, Comparator.comparing(String::length)); // 按长度排序 
System.out.println(Arrays.toString(names)); // [Bob, Alice, Chaarlie]

//or

Arrays.sort(names, (a, b) -> b.length() - a.length()); // 按长度降序排序
System.out.println(Arrays.toString(names)); // [Charlie, Alice, Bob]

按对象属性排序

class Person {
    String name;
    int age;

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return name + " (" + age + ")";
    }
}

List<Person> people = Arrays.asList(
            new Person("Alice", 30),
            new Person("Bob", 25),
            new Person("Charlie", 35)
        );

people.sort(new Comparator<Person>() { 
		@Override 
    public int compare(Person p1, Person p2) { 
        return p1.name.compareTo(p2.name); 
    } 
});

或者使用lambda

people.sort((p1, p2) -> p1.age - p2.age); 
System.out.println(people); // 按年龄升序排序

或结合 Comparator 的静态方法：

people.sort(Comparator.comparingInt(p -> p.age));

多字段排序

people.sort( 
    Comparator.comparing(Person::getAge) 
                       .thenComparing(Person::getName) 
);

按字段逆序排序

people.sort(Comparator.comparing(Person::getAge).reversed());

处理可能为 null 的字段时，可以使用 nullsFirst 或 nullsLast。

people.sort( Comparator.comparing(Person::getName, Comparator.nullsFirst(String::compareTo)) );

我们可根据场景自取合适的排序方式。