Java中如何对List集合进行排序-Java-PHP中文网

Java中如何对List集合进行排序

尼克

发布： 2025-06-28 23:48:02

原创

303人浏览过

对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。

Java中如何对List集合进行排序

对List集合进行排序，简单来说，就是让集合里的元素按照某种规则排列。Java提供了多种方式来实现，可以用Collections.sort()，也可以用List自身的sort()方法，甚至可以自己实现排序算法。

解决方案

Java中对List集合进行排序，主要有以下几种方法，各有优劣，选择哪个取决于你的具体需求：

立即学习“Java免费学习笔记（深入）”；

Collections.sort()方法： 这是最常用的方法，它使用归并排序或Timsort（一种混合排序算法，优化了归并排序）来对List进行排序。

优点： 简单易用，性能较好（尤其是对于大型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自带的排序算法已经足够高效。
- 优点： 灵活，可以满足各种复杂的排序需求。
- 缺点： 实现复杂，容易出错，性能可能不如Java自带的排序算法。

使用Stream API： Java 8的Stream API也提供了排序功能，可以对List进行排序，并返回一个新的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进行排序？

当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？

如果在排序过程中遇到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]
    }
}

登录后复制

如何选择合适的排序方法？

选择合适的排序方法，需要考虑以下几个因素：

List的大小： 对于小型List，Collections.sort()和List自身的sort()方法性能差异不大。对于大型List，Collections.sort()可能更高效。
元素类型： 如果元素已经实现了Comparable接口，可以直接使用Collections.sort()或List自身的sort()方法。否则，需要提供一个Comparator。
排序规则的复杂性： 如果排序规则比较简单，可以使用Comparator.comparing()等方法简化代码。如果排序规则非常复杂，可能需要自定义Comparator。
是否需要创建新的List： 如果不需要创建新的List，可以使用Collections.sort()或List自身的sort()方法。如果需要创建一个新的排序后的List，可以使用Stream API。
是否需要处理null值： 如果List中可能包含null值，需要使用Comparator.nullsFirst()、Comparator.nullsLast()或自定义Comparator来处理null值。

总而言之，没有一种排序方法是万能的，需要根据具体情况选择最合适的方法。优先考虑使用Java提供的排序方法，它们通常已经足够高效和稳定。只有在特殊情况下，才需要考虑自定义排序算法。

以上就是Java中如何对List集合进行排序的详细内容，更多请关注php中文网其它相关文章！