java如何实现集合的排序与筛选 java集合排序筛选的详细方法指南-java教程-PHP中文网

<p>java中对自定义对象集合排序需使用comparator接口，1. 可通过collections.sort()或list.sort()方法传入comparator实现排序；2. java 8后可使用lambda表达式简化比较逻辑，如users.sort((u1, u2) -> u1.getage() - u2.getage())；3. 利用comparator.comparing()和thencomparing()支持多字段组合排序；4. 可通过reversed()反转排序顺序；5. 需注意null值处理，可结合comparator.nullsfirst()或nullslast()避免空指针异常；该方式灵活高效，适用于复杂排序场景，最终实现对象集合按自定义规则有序排列。</p>

java如何实现集合的排序与筛选 java集合排序筛选的详细方法指南

Java集合的排序与筛选，说白了，就是如何让你的数据按照你想要的方式排列，或者只留下你关心的数据。这在日常开发里，几乎是绕不开的话题。从最基础的列表操作，到更复杂的对象集合处理，掌握这些方法能让你在处理数据时游刃有余，代码也显得更清晰、更高效。

解决方案

集合的排序，在Java里主要围绕着

List

登录后复制

接口展开。最直接的方式，就是利用

Collections.sort()

登录后复制

方法，它能对列表进行自然排序，或者根据你提供的

Comparator

登录后复制

进行自定义排序。当然，Java 8之后，

List

登录后复制

接口本身也多了一个

sort()

登录后复制

方法，用起来更直接。

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;

// 假设我们有一个简单的User类
class User {
    String name;
    int age;

    public User(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 "User{" + "name='" + name + '\'' + ", age=" + age + '}';
    }
}

public class CollectionOperations {

    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        names.add("Alice");
        names.add("Charlie");
        names.add("Bob");

        // 字符串列表的自然排序
        Collections.sort(names);
        System.out.println("自然排序后: " + names); // [Alice, Bob, Charlie]

        List<User> users = new ArrayList<>();
        users.add(new User("Alice", 30));
        users.add(new User("Bob", 25));
        users.add(new User("Charlie", 35));
        users.add(new User("David", 25));

        // 按年龄排序 (使用List.sort和Lambda)
        users.sort(Comparator.comparingInt(User::getAge));
        System.out.println("按年龄排序后: " + users);

        // 如果想用Stream API排序，会生成一个新的List
        List<User> sortedUsersByAgeStream = users.stream()
                                               .sorted(Comparator.comparingInt(User::getAge))
                                               .collect(Collectors.toList());
        System.out.println("Stream按年龄排序后: " + sortedUsersByAgeStream);
    }
}

登录后复制

至于筛选，Java 8引入的Stream API简直是神器。它提供了一种声明式的方式来处理集合，

filter()

登录后复制

方法就是其中一个核心。当然，如果你需要原地修改集合，

Collection

登录后复制

接口的

removeIf()

登录后复制

方法也挺方便。

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

import java.util.ArrayList;
import java.util.List;
import java.util.Iterator;
import java.util.stream.Collectors;

public class FilteringExamples {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.add(4);
        numbers.add(5);

        // 使用Stream API筛选偶数，生成新列表
        List<Integer> evenNumbers = numbers.stream()
                                           .filter(n -> n % 2 == 0)
                                           .collect(Collectors.toList());
        System.out.println("筛选偶数 (Stream): " + evenNumbers); // [2, 4]
        System.out.println("原列表 (Stream筛选后不变): " + numbers); // [1, 2, 3, 4, 5]

        // 使用removeIf原地筛选奇数 (会修改原列表)
        List<Integer> mutableNumbers = new ArrayList<>(numbers); // 复制一份，避免修改原numbers
        mutableNumbers.removeIf(n -> n % 2 != 0); // 移除所有奇数
        System.out.println("筛选偶数 (removeIf): " + mutableNumbers); // [2, 4]
        System.out.println("原列表 (removeIf修改后): " + mutableNumbers); // [2, 4]

        // 传统迭代器筛选 (适用于Java 8以前或特定场景)
        List<Integer> oldSchoolNumbers = new ArrayList<>(numbers);
        Iterator<Integer> iterator = oldSchoolNumbers.iterator();
        while (iterator.hasNext()) {
            Integer num = iterator.next();
            if (num > 3) {
                iterator.remove(); // 移除大于3的数
            }
        }
        System.out.println("传统迭代器筛选 (移除大于3的): " + oldSchoolNumbers); // [1, 2, 3]
    }
}

登录后复制

Java中，如何根据自定义规则对对象集合进行排序？

对自定义对象进行排序，这可是个高频需求。光靠对象本身的自然顺序（如果它实现了

Comparable

登录后复制

接口），很多时候是不够的。比如，你有一堆

User

登录后复制

对象，可能需要按年龄排序，也可能需要按姓名排序，甚至先按年龄再按姓名。这时候，

Comparator

登录后复制

接口就闪亮登场了。

Comparator

登录后复制

是一个函数式接口，它定义了一个

compare(T o1, T o2)

登录后复制

方法，用于比较两个对象。返回值是负数表示

o1

登录后复制

小于

o2

登录后复制

，正数表示

o1

登录后复制

大于

o2

登录后复制

，零表示相等。

在Java 8之前，我们通常会写一个匿名内部类来实现

Comparator

登录后复制

：

// 假设有List<User> users
// 按年龄降序排序
users.sort(new Comparator<User>() {
    @Override
    public int compare(User u1, User u2) {
        return Integer.compare(u2.getAge(), u1.getAge()); // 降序
    }
});
System.out.println("按年龄降序排序 (匿名内部类): " + users);

登录后复制

Java 8之后，有了Lambda表达式，代码瞬间简洁明了：

// 按姓名升序排序
users.sort((u1, u2) -> u1.getName().compareTo(u2.getName()));
System.out.println("按姓名升序排序 (Lambda): " + users);

登录后复制

更进一步，

Comparator

登录后复制

接口本身也提供了很多静态辅助方法，让组合排序变得异常优雅。

Comparator.comparing()

登录后复制

可以帮你轻松指定一个排序键，而

thenComparing()

登录后复制

则可以链式地添加次要排序规则。

// 先按年龄升序，年龄相同则按姓名升序
users.sort(Comparator.comparingInt(User::getAge)
                     .thenComparing(User::getName));
System.out.println("先按年龄再按姓名排序: " + users);

// 如果需要反转顺序，可以加个reversed()
users.sort(Comparator.comparingInt(User::getAge).reversed() // 年龄降序
                     .thenComparing(User::getName)); // 姓名升序
System.out.println("先按年龄降序再按姓名升序: " + users);

登录后复制

这种写法，读起来就像在说人话，逻辑一目了然。在我看来，这是Java 8在集合操作方面带来的最大福音之一。

Java 8 Stream API在集合筛选中有什么优势？

Stream API的出现，彻底改变了Java集合操作的范式。它提供了一种声明式、函数式编程风格来处理数据，尤其在筛选（filter）场景下，优势简直不要太明显。

它的核心优势在于：

声明式编程： 你不再需要写一堆循环和条件判断来描述“怎么做”，而是直接告诉Stream“做什么”。比如，
```
filter(n -> n % 2 == 0)
```
登录后复制
就直接表达了“我想要偶数”，而不是“遍历每个元素，如果它是偶数就把它加到新列表里”。这种高层次的抽象让代码更易读、更易维护。

集简云
软件集成平台，快速建立企业自动化与智能化

22

查看详情

链式操作： Stream操作可以像管道一样连接起来，形成一个处理流水线。你可以先

filter

登录后复制

筛选，再

map

登录后复制

转换，然后

sorted

登录后复制

排序，最后

collect

登录后复制

收集。整个过程一气呵成，非常流畅，避免了创建大量中间变量。

List<String> names = List.of("Alice", "Bob", "Charlie", "David", "Eve");
// 筛选出名字长度大于3且以'A'开头的名字，并转换为大写，然后排序
List<String> processedNames = names.stream()
                                   .filter(name -> name.length() > 3) // 筛选长度大于3
                                   .filter(name -> name.startsWith("A")) // 再筛选以'A'开头
                                   .map(String::toUpperCase) // 转换为大写
                                   .sorted() // 排序
                                   .collect(Collectors.toList()); // 收集成新列表
System.out.println("Stream链式处理: " + processedNames); // [ALICE]

登录后复制

惰性求值： Stream的大部分中间操作（如
```
filter
```
登录后复制
,
```
map
```
登录后复制
,
```
sorted
```
登录后复制
）都是惰性求值的。这意味着它们不会立即执行，只有当你调用一个终结操作（如
```
collect
```
登录后复制
,
```
forEach
```
登录后复制
,
```
count
```
登录后复制
）时，整个流水线才会真正开始执行。这在处理大数据量时，可以带来性能上的优化，因为它允许JIT编译器进行更多的优化，比如短路操作。

内部迭代： Stream API采用内部迭代，将迭代的控制权交给了库本身。这使得它能够更好地利用多核处理器，通过

parallelStream()

登录后复制

轻松实现并行处理，而你几乎不需要关心线程同步的复杂性。

List<Integer> largeNumbers = new ArrayList<>();
for (int i = 0; i < 1000000; i++) {
    largeNumbers.add(i);
}
long count = largeNumbers.parallelStream() // 开启并行流
                         .filter(n -> n % 2 == 0)
                         .count();
System.out.println("并行筛选偶数数量: " + count);

登录后复制

当然，Stream API也有它不那么“完美”的地方，比如它总是生成新的集合，如果你需要原地修改，可能还需要考虑

removeIf

登录后复制

。但总的来说，对于筛选和转换这种场景，Stream API无疑是现代Java开发的首选。

在Java集合排序与筛选时，有哪些常见的性能考量和注意事项？

处理集合的排序和筛选，光知道怎么写代码还不够，理解背后的性能考量和一些潜在的坑，能让你写出更健壮、更高效的应用。

算法复杂度：
- ```
Collections.sort()
```
  登录后复制
  和
```
List.sort()
```
  登录后复制
  底层使用的是Timsort算法，它的平均和最坏时间复杂度都是O(n log n)，这在大多数情况下都是非常高效的。
- ```
Stream.sorted()
```
  登录后复制
  也通常是O(n log n)。
- 而像
```
removeIf()
```
  登录后复制
  或Stream的
```
filter()
```
  登录后复制
  操作，它们都需要遍历集合，所以时间复杂度至少是O(n)。理解这些基本复杂度，能帮你预估在大数据量下的表现。
原地修改 vs. 创建新集合：
- ```
List.sort()
```
  登录后复制
  和
```
Collection.removeIf()
```
  登录后复制
  会直接修改原始集合。如果你需要保留原始数据，或者你的集合是不可变的（比如
```
List.of()
```
  登录后复制
  创建的列表），那么它们就不适用，或者你需要先复制一份。
- Stream API的中间操作（如
```
filter
```
  登录后复制
  ,
```
map
```
  登录后复制
  ,
```
sorted
```
  登录后复制
  ）通常不会修改源集合，而是生成新的流或在终结操作时收集成新的集合。这符合函数式编程的理念，减少了副作用，但同时也意味着可能需要额外的内存来存储新的集合。在内存敏感的场景下，这一点需要注意。
Comparator和Predicate的性能：
- 你为
```
Comparator
```
  登录后复制
  或
```
Predicate
```
  登录后复制
  提供的逻辑，其内部的计算复杂度直接影响了整个排序或筛选过程的性能。如果你的比较或判断逻辑非常复杂，甚至涉及IO操作或网络请求，那性能瓶颈很可能出在这里，而不是集合操作本身。
- 避免在
```
compare
```
  登录后复制
  或
```
test
```
  登录后复制
  方法中执行耗时操作。
空值（Null）处理：
- 当集合中可能包含
```
null
```
  登录后复制
  元素时，排序和筛选需要特别小心。
- ```
Comparator.comparing()
```
  登录后复制
  默认对
```
null
```
  登录后复制
  不友好，如果你的getter方法返回
```
null
```
  登录后复制
  ，或者集合中直接有
```
null
```
  登录后复制
  元素，很可能会抛出
```
NullPointerException
```
  登录后复制
  。你可以使用
```
Comparator.nullsFirst()
```
  登录后复制
  或
```
Comparator.nullsLast()
```
  登录后复制
  来处理
```
null
```
  登录后复制
  值。
- 筛选时，如果
```
Predicate
```
  登录后复制
  没有考虑到
```
null
```
  登录后复制
  ，也可能导致意料之外的错误。
并行流的开销：
- ```
parallelStream()
```
  登录后复制
  听起来很美，但并不是所有场景都适合。并行处理有其自身的开销，包括线程创建、任务调度、结果合并等。对于小规模数据（比如几千个元素以内），并行流的开销可能大于它带来的性能收益，甚至会更慢。
- 只有当数据量足够大，且你的操作是CPU密集型时，并行流的优势才能体现出来。同时，避免在并行流中使用有状态的Lambda表达式或修改共享变量，这会导致线程安全问题。
迭代器的并发修改问题：
- 如果你在遍历集合（比如使用增强for循环或
```
Iterator
```
  登录后复制
  ）的同时修改了集合的结构（添加、删除元素），除了
```
Iterator.remove()
```
  登录后复制
  之外，通常会抛出
```
ConcurrentModificationException
```
  登录后复制
  。
- Stream API和
```
removeIf()
```
  登录后复制
  在内部处理了这个问题，所以使用它们时通常不会遇到。但如果你还在用传统的迭代方式，务必注意。