Java集合排序筛选技巧全解析

一分耕耘，一分收获！既然都打开这篇《Java集合排序与筛选全攻略》，就坚持看下去，学下去吧！本文主要会给大家讲到等等知识点，如果大家对本文有好的建议或者看到有不足之处，非常欢迎大家积极提出！在后续文章我会继续更新文章相关的内容，希望对大家都有所帮助！

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()避免空指针异常；该方式灵活高效，适用于复杂排序场景，最终实现对象集合按自定义规则有序排列。

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()方法也挺方便。

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）场景下，优势简直不要太明显。

它的核心优势在于：

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

2. 链式操作： 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]

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

4. 内部迭代： 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集合排序与筛选时，有哪些常见的性能考量和注意事项？

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

1. 算法复杂度：

   • Collections.sort()和List.sort()底层使用的是Timsort算法，它的平均和最坏时间复杂度都是O(n log n)，这在大多数情况下都是非常高效的。
   • Stream.sorted()也通常是O(n log n)。
   • 而像removeIf()或Stream的filter()操作，它们都需要遍历集合，所以时间复杂度至少是O(n)。理解这些基本复杂度，能帮你预估在大数据量下的表现。

2. 原地修改 vs. 创建新集合：

   • List.sort()和Collection.removeIf()会直接修改原始集合。如果你需要保留原始数据，或者你的集合是不可变的（比如List.of()创建的列表），那么它们就不适用，或者你需要先复制一份。
   • Stream API的中间操作（如filter, map, sorted）通常不会修改源集合，而是生成新的流或在终结操作时收集成新的集合。这符合函数式编程的理念，减少了副作用，但同时也意味着可能需要额外的内存来存储新的集合。在内存敏感的场景下，这一点需要注意。

3. Comparator和Predicate的性能：

   • 你为Comparator或Predicate提供的逻辑，其内部的计算复杂度直接影响了整个排序或筛选过程的性能。如果你的比较或判断逻辑非常复杂，甚至涉及IO操作或网络请求，那性能瓶颈很可能出在这里，而不是集合操作本身。
   • 避免在compare或test方法中执行耗时操作。

4. 空值（Null）处理：

   • 当集合中可能包含null元素时，排序和筛选需要特别小心。
   • Comparator.comparing()默认对null不友好，如果你的getter方法返回null，或者集合中直接有null元素，很可能会抛出NullPointerException。你可以使用Comparator.nullsFirst()或Comparator.nullsLast()来处理null值。
   • 筛选时，如果Predicate没有考虑到null，也可能导致意料之外的错误。

5. 并行流的开销：

   • parallelStream()听起来很美，但并不是所有场景都适合。并行处理有其自身的开销，包括线程创建、任务调度、结果合并等。对于小规模数据（比如几千个元素以内），并行流的开销可能大于它带来的性能收益，甚至会更慢。
   • 只有当数据量足够大，且你的操作是CPU密集型时，并行流的优势才能体现出来。同时，避免在并行流中使用有状态的Lambda表达式或修改共享变量，这会导致线程安全问题。

6. 迭代器的并发修改问题：

   • 如果你在遍历集合（比如使用增强for循环或Iterator）的同时修改了集合的结构（添加、删除元素），除了Iterator.remove()之外，通常会抛出ConcurrentModificationException。
   • Stream API和removeIf()在内部处理了这个问题，所以使用它们时通常不会遇到。但如果你还在用传统的迭代方式，务必注意。

总之，选择合适的排序和筛选方法，不仅要看功能是否满足，更要结合数据规模、性能要求以及是否需要原地修改等因素综合考虑。没有银弹，只有最适合你当前场景的方案。

今天关于《Java集合排序筛选技巧全解析》的内容介绍就到此结束，如果有什么疑问或者建议，可以在golang学习网公众号下多多回复交流；文中若有不正之处，也希望回复留言以告知！