Java 中的 Stream Filter 示例详解

简介

在 Java 8 引入 Stream API 之后，处理集合数据变得更加简洁和高效。Stream Filter 作为 Stream API 的重要操作之一，它允许我们根据特定条件对数据流中的元素进行筛选，从而得到符合条件的元素集合。这篇博客将深入探讨 Java 中 Stream Filter 的基础概念、使用方法、常见实践以及最佳实践，帮助你更好地掌握这一强大的功能。

基础概念

Stream 是 Java 8 引入的一个接口，它代表了一系列支持顺序和并行聚合操作的元素。Stream Filter 是 Stream API 中的中间操作，它接收一个 Predicate（断言）作为参数，并返回一个由符合断言条件的元素组成的新流。简单来说，就是根据给定的条件对 Stream 中的元素进行过滤。

例如，假设有一个整数列表 [1, 2, 3, 4, 5]，我们想要筛选出其中的偶数。使用 Stream Filter 可以轻松实现：

import java.util.Arrays;
import java.util.List;

public class StreamFilterExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        numbers.stream()
              .filter(number -> number % 2 == 0)
              .forEach(System.out::println);
    }
}

在上述代码中，numbers.stream() 创建了一个 Stream，filter(number -> number % 2 == 0) 使用 lambda 表达式作为断言，筛选出偶数，最后 forEach(System.out::println) 将筛选后的元素打印出来。

使用方法

Stream Filter 的基本使用方法非常简单，只需调用 stream() 方法将集合转换为流，然后调用 filter() 方法并传入一个 Predicate。Predicate 是一个函数式接口，它接收一个参数并返回一个布尔值，表示该参数是否符合条件。

语法

Stream<T> filter(Predicate<? super T> predicate)

其中，T 是流中元素的类型，predicate 是用于筛选元素的断言。

示例

import java.util.Arrays;
import java.util.List;

public class StreamFilterUsage {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");

        // 筛选出名字长度大于 4 的元素
        names.stream()
             .filter(name -> name.length() > 4)
             .forEach(System.out::println);
    }
}

在这个示例中，filter(name -> name.length() > 4) 筛选出了名字长度大于 4 的字符串，并通过 forEach 打印出来。

常见实践

筛选数字集合

筛选数字集合是 Stream Filter 的常见应用场景之一。例如，我们可能想要从一个数字列表中筛选出大于某个值的数字，或者筛选出质数等。

import java.util.Arrays;
import java.util.List;

public class NumberFilterExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        // 筛选出大于 5 的数字
        numbers.stream()
              .filter(number -> number > 5)
              .forEach(System.out::println);

        // 筛选出质数
        numbers.stream()
              .filter(NumberFilterExample::isPrime)
              .forEach(System.out::println);
    }

    private static boolean isPrime(int number) {
        if (number <= 1) return false;
        if (number <= 3) return true;
        if (number % 2 == 0 || number % 3 == 0) return false;
        for (int i = 5; i * i <= number; i += 6) {
            if (number % i == 0 || number % (i + 2) == 0) return false;
        }
        return true;
    }
}

筛选对象集合

在实际开发中，我们更多地是对对象集合进行筛选。例如，有一个学生类 Student，包含 name 和 age 属性，我们想要筛选出年龄大于某个值的学生。

import java.util.Arrays;
import java.util.List;

class Student {
    private String name;
    private int age;

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

public class StudentFilterExample {
    public static void main(String[] args) {
        List<Student> students = Arrays.asList(
                new Student("Alice", 20),
                new Student("Bob", 22),
                new Student("Charlie", 18)
        );

        // 筛选出年龄大于 20 的学生
        students.stream()
              .filter(student -> student.getAge() > 20)
              .forEach(System.out::println);
    }
}

最佳实践

性能优化

避免不必要的装箱和拆箱：在处理基本数据类型时，尽量使用对应的原始流（如 IntStream、DoubleStream 等），避免自动装箱和拆箱带来的性能开销。

import java.util.Arrays;
import java.util.List;
import java.util.stream.IntStream;

public class PerformanceOptimization {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

        // 使用原始流
        IntStream intStream = numbers.stream().mapToInt(Integer::intValue);
        intStream.filter(number -> number % 2 == 0).forEach(System.out::println);
    }
}

并行处理：对于大规模数据集，可以考虑使用并行流来提高处理速度。但需要注意的是，并行流在某些情况下可能会带来线程安全问题和额外的开销，需要根据具体情况进行权衡。

import java.util.Arrays;
import java.util.List;

public class ParallelStreamExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        // 使用并行流
        numbers.parallelStream()
              .filter(number -> number % 2 == 0)
              .forEach(System.out::println);
    }
}

代码可读性

提取复杂的 Predicate：如果 Predicate 逻辑比较复杂，建议将其提取为一个单独的方法，这样可以提高代码的可读性和可维护性。

import java.util.Arrays;
import java.util.List;

public class ReadabilityExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");

        names.stream()
             .filter(ReadabilityExample::isValidName)
             .forEach(System.out::println);
    }

    private static boolean isValidName(String name) {
        return name.length() > 3 && name.startsWith("A");
    }
}

小结

Stream Filter 是 Java 中处理集合数据的强大工具，通过简洁的语法和丰富的功能，可以帮助我们高效地筛选出符合条件的元素。在实际应用中，我们需要根据具体需求合理使用 Stream Filter，并注意性能优化和代码可读性，以写出高质量的代码。

参考资料

希望这篇博客能帮助你更好地理解和使用 Java 中的 Stream Filter。如果你有任何问题或建议，欢迎在评论区留言。