对list集合排序的方法有四种，分别是使用collections.sort()、list的sort()方法、自定义排序算法和stream api。1.collections.sort()适用于实现comparable接口的对象或提供comparator；2.list的sort()方法语法更简洁，功能相同；3.自定义排序灵活但复杂且不推荐，除非有特殊需求；4.stream api支持函数式编程风格，返回新list。对于包含对象的list，可通过实现comparable接口或提供comparator进行排序，并可用nullsfirst/nullslast处理空值。选择方法需考虑list大小、元素类型、排序规则复杂度及是否需要新list。
对List集合进行排序，简单来说，就是让集合里的元素按照某种规则排列。Java提供了多种方式来实现，可以用Collections.sort()，也可以用List自身的sort()方法，甚至可以自己实现排序算法。
解决方案
Java中对List集合进行排序，主要有以下几种方法，各有优劣，选择哪个取决于你的具体需求：
立即学习“Java免费学习笔记（深入）”；
Collections.sort()方法： 这是最常用的方法，它使用归并排序或Timsort（一种混合排序算法，优化了归并排序）来对List进行排序。
Comparable接口的元素进行排序，或者需要提供一个Comparator。import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class ListSortExample {
public static void main(String[] args) {
List<Integer> numbers = new ArrayList<>();
numbers.add(5);
numbers.add(2);
numbers.add(8);
numbers.add(1);
Collections.sort(numbers); // 默认升序排序
System.out.println(numbers); // 输出：[1, 2, 5, 8]
// 使用Comparator进行降序排序
Collections.sort(numbers, (a, b) -> b.compareTo(a));
System.out.println(numbers); // 输出：[8, 5, 2, 1]
}
}List自身的sort()方法： Java 8之后，List接口新增了sort()方法，功能与Collections.sort()类似，但使用起来更简洁。
Collections.sort()类似，需要Comparable接口或Comparator。 import java.util.ArrayList;
import java.util.List;
public class ListSortExample {
public static void main(String[] args) {
List<String> names = new ArrayList<>();
names.add("Charlie");
names.add("Alice");
names.add("Bob");
names.sort(String::compareTo); // 默认升序排序
System.out.println(names); // 输出：[Alice, Bob, Charlie]
// 使用Comparator进行降序排序
names.sort((a, b) -> b.compareTo(a));
System.out.println(names); // 输出：[Charlie, Bob, Alice]
}
}自定义排序算法： 如果你需要更精细的控制，或者Java自带的排序算法不满足你的需求，可以自己实现排序算法，比如冒泡排序、插入排序、快速排序等。 不过，除非有特殊情况，否则不建议自己实现排序算法，因为Java自带的排序算法已经足够高效。
使用Stream API： Java 8的Stream API也提供了排序功能，可以对List进行排序，并返回一个新的List。
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class ListSortExample {
public static void main(String[] args) {
List<Double> prices = new ArrayList<>();
prices.add(19.99);
prices.add(9.99);
prices.add(29.99);
List<Double> sortedPrices = prices.stream()
.sorted() // 默认升序排序
.collect(Collectors.toList());
System.out.println(sortedPrices); // 输出：[9.99, 19.99, 29.99]
// 使用Comparator进行降序排序
List<Double> reverseSortedPrices = prices.stream()
.sorted((a, b) -> b.compareTo(a))
.collect(Collectors.toList());
System.out.println(reverseSortedPrices); // 输出：[29.99, 19.99, 9.99]
}
}当List中包含的是自定义对象时，需要让对象实现Comparable接口，或者提供一个Comparator。
实现Comparable接口： 让对象自身具备比较能力。
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
class Person implements Comparable<Person> {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
@Override
public int compareTo(Person other) {
// 按照年龄升序排序
return this.age - other.age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
public class ListSortExample {
public static void main(String[] args) {
List<Person> people = new ArrayList<>();
people.add(new Person("Alice", 30));
people.add(new Person("Bob", 25));
people.add(new Person("Charlie", 35));
Collections.sort(people); // 按照年龄升序排序
System.out.println(people);
// 输出：
// [Person{name='Bob', age=25}, Person{name='Alice', age=30}, Person{name='Charlie', age=35}]
}
}提供Comparator： 在排序时提供一个比较器，可以灵活地定义排序规则。
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
public class ListSortExample {
public static void main(String[] args) {
List<Person> people = new ArrayList<>();
people.add(new Person("Alice", 30));
people.add(new Person("Bob", 25));
people.add(new Person("Charlie", 35));
// 按照姓名升序排序
Collections.sort(people, Comparator.comparing(Person::getName));
System.out.println(people);
// 输出：
// [Person{name='Alice', age=30}, Person{name='Bob', age=25}, Person{name='Charlie', age=35}]
// 按照年龄降序排序
Collections.sort(people, (p1, p2) -> p2.getAge() - p1.getAge());
System.out.println(people);
// 输出：
// [Person{name='Charlie', age=35}, Person{name='Alice', age=30}, Person{name='Bob', age=25}]
}
}如果在排序过程中遇到NullPointerException，通常是因为List中存在null元素，而compareTo()方法无法处理null值。 解决这个问题，可以采用以下几种方法：
过滤掉null元素： 在排序之前，先将List中的null元素过滤掉。
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
public class ListSortExample {
public static void main(String[] args) {
List<String> names = new ArrayList<>();
names.add("Charlie");
names.add(null);
names.add("Alice");
names.add("Bob");
// 过滤掉null元素
List<String> nonNullNames = names.stream()
.filter(name -> name != null)
.collect(Collectors.toList());
Collections.sort(nonNullNames);
System.out.println(nonNullNames); // 输出：[Alice, Bob, Charlie]
}
}使用Comparator.nullsFirst()或Comparator.nullsLast()： 这两个方法可以指定null值在排序结果中的位置。
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class ListSortExample {
public static void main(String[] args) {
List<String> names = new ArrayList<>();
names.add("Charlie");
names.add(null);
names.add("Alice");
names.add("Bob");
// null值排在最前面
Collections.sort(names, Comparator.nullsFirst(String::compareTo));
System.out.println(names); // 输出：[null, Alice, Bob, Charlie]
// null值排在最后面
Collections.sort(names, Comparator.nullsLast(String::compareTo));
System.out.println(names); // 输出：[Alice, Bob, Charlie, null]
}
}自定义Comparator处理null值： 在自定义Comparator中，显式地处理null值。
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class ListSortExample {
public static void main(String[] args) {
List<String> names = new ArrayList<>();
names.add("Charlie");
names.add(null);
names.add("Alice");
names.add("Bob");
Collections.sort(names, (a, b) -> {
if (a == null && b == null) {
return 0;
} else if (a == null) {
return -1; // null值排在前面
} else if (b == null) {
return 1; // null值排在后面
} else {
return a.compareTo(b);
}
});
System.out.println(names); // 输出：[null, Alice, Bob, Charlie]
}
}选择合适的排序方法，需要考虑以下几个因素：
Collections.sort()和List自身的sort()方法性能差异不大。对于大型List，Collections.sort()可能更高效。Comparable接口，可以直接使用Collections.sort()或List自身的sort()方法。否则，需要提供一个Comparator。Comparator.comparing()等方法简化代码。如果排序规则非常复杂，可能需要自定义Comparator。Collections.sort()或List自身的sort()方法。如果需要创建一个新的排序后的List，可以使用Stream API。Comparator.nullsFirst()、Comparator.nullsLast()或自定义Comparator来处理null值。总而言之，没有一种排序方法是万能的，需要根据具体情况选择最合适的方法。 优先考虑使用Java提供的排序方法，它们通常已经足够高效和稳定。只有在特殊情况下，才需要考虑自定义排序算法。
以上就是Java中如何对List集合进行排序的详细内容，更多请关注php中文网其它相关文章！
每个人都需要一台速度更快、更稳定的 PC。随着时间的推移，垃圾文件、旧注册表数据和不必要的后台进程会占用资源并降低性能。幸运的是，许多工具可以让 Windows 保持平稳运行。
广告Copyright 2014-2025 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号
870
收藏
