跳转至

Java 中的 Stream Filter 示例：深入解析与实践

简介

在 Java 编程中，Stream API 是一个强大的工具，它为处理集合数据提供了一种简洁、高效且声明式的方式。其中，filter 操作是 Stream API 中非常常用的功能之一，它允许我们根据特定条件筛选出流中的元素。通过使用 filter，我们可以避免传统的迭代循环，从而编写出更简洁、可读性更高的代码。本文将详细介绍 Java 中 stream filter 的基础概念、使用方法、常见实践以及最佳实践，并提供丰富的代码示例，帮助读者更好地理解和运用这一特性。

目录

  1. 基础概念
    • 什么是 Stream
    • 什么是 Filter
  2. 使用方法
    • 创建 Stream
    • 使用 filter 方法
  3. 常见实践
    • 按条件筛选对象
    • 排除特定元素
  4. 最佳实践
    • 性能优化
    • 代码可读性提升
  5. 小结
  6. 参考资料

基础概念

什么是 Stream

Stream 是 Java 8 引入的一个新抽象，它代表了一系列支持顺序和并行聚合操作的元素。Stream 不是数据结构，它不存储数据，而是对数据源（如集合、数组等）进行操作。Stream 操作可以分为中间操作和终端操作。中间操作返回一个新的流，允许我们链式调用多个操作；终端操作会触发流的处理，并返回最终结果。

什么是 Filter

filter 是 Stream API 中的一个中间操作，它接受一个谓词（Predicate）作为参数，并返回一个由符合该谓词条件的元素组成的新流。谓词是一个返回布尔值的函数，用于判断元素是否满足特定条件。通过 filter，我们可以从原始流中筛选出我们感兴趣的元素，从而进一步处理这些元素。

使用方法

创建 Stream

在使用 filter 之前，我们需要先创建一个 Stream。以下是几种常见的创建 Stream 的方式： - 从集合创建 Stream

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

public class StreamExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        numbers.stream(); // 创建一个顺序流
        numbers.parallelStream(); // 创建一个并行流
    }
}
  • 从数组创建 Stream
import java.util.Arrays;
import java.util.stream.Stream;

public class ArrayStreamExample {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};
        IntStream intStream = Arrays.stream(numbers); // 创建一个 IntStream
        Stream<int[]> arrayStream = Stream.of(numbers); // 创建一个包含数组的 Stream
    }
}

使用 filter 方法

filter 方法的语法如下：

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

其中，T 是流中元素的类型，predicate 是一个用于筛选元素的谓词。

以下是一个简单的示例，筛选出列表中的偶数：

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

public class FilterExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        List<Integer> evenNumbers = numbers.stream()
               .filter(number -> number % 2 == 0)
               .collect(Collectors.toList());
        System.out.println(evenNumbers); // 输出: [2, 4, 6, 8, 10]
    }
}

在上述示例中，我们使用 filter 方法筛选出 numbers 列表中的偶数，并将结果收集到一个新的列表 evenNumbers 中。filter 方法中的谓词 number -> number % 2 == 0 判断每个元素是否为偶数。

常见实践

按条件筛选对象

假设我们有一个包含学生对象的列表，每个学生对象有姓名和年龄属性。我们可以使用 filter 方法筛选出年龄大于 18 岁的学生：

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

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;
    }
}

public class StudentFilterExample {
    public static void main(String[] args) {
        List<Student> students = new ArrayList<>();
        students.add(new Student("Alice", 16));
        students.add(new Student("Bob", 20));
        students.add(new Student("Charlie", 19));

        List<Student> adultStudents = students.stream()
               .filter(student -> student.getAge() > 18)
               .collect(Collectors.toList());

        adultStudents.forEach(student -> System.out.println(student.getName() + " is an adult."));
    }
}

排除特定元素

有时候我们需要从流中排除某些特定元素。例如，我们有一个字符串列表，需要排除其中的空字符串：

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

public class EmptyStringFilterExample {
    public static void main(String[] args) {
        List<String> strings = Arrays.asList("apple", "", "banana", "", "cherry");
        List<String> nonEmptyStrings = strings.stream()
               .filter(str ->!str.isEmpty())
               .collect(Collectors.toList());
        System.out.println(nonEmptyStrings); // 输出: [apple, banana, cherry]
    }
}

最佳实践

性能优化

  • 并行处理：对于大规模数据集，可以使用并行流来提高处理速度。通过调用 parallelStream() 方法将顺序流转换为并行流，让多个元素可以同时进行筛选操作。
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class ParallelFilterExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        List<Integer> evenNumbers = numbers.parallelStream()
               .filter(number -> number % 2 == 0)
               .collect(Collectors.toList());
        System.out.println(evenNumbers);
    }
}
  • 避免不必要的装箱和拆箱：如果流中的元素是基本数据类型，尽量使用对应的原始类型流（如 IntStream、DoubleStream 等），以避免自动装箱和拆箱带来的性能开销。

代码可读性提升

  • 使用方法引用：如果谓词逻辑已经存在于一个方法中，可以使用方法引用代替 Lambda 表达式，使代码更简洁易读。
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class MethodReferenceFilterExample {
    public static boolean isEven(int number) {
        return number % 2 == 0;
    }

    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        List<Integer> evenNumbers = numbers.stream()
               .filter(MethodReferenceFilterExample::isEven)
               .collect(Collectors.toList());
        System.out.println(evenNumbers);
    }
}
  • 提取复杂谓词：如果谓词逻辑比较复杂，可以将其提取到一个单独的方法中，这样可以提高代码的可读性和可维护性。

小结

本文详细介绍了 Java 中 stream filter 的相关知识，包括基础概念、使用方法、常见实践以及最佳实践。通过使用 filter 方法，我们可以更简洁、高效地筛选流中的元素，提高代码的可读性和性能。在实际应用中，我们应根据具体需求合理选择使用顺序流或并行流，并注意性能优化和代码可读性的提升。希望本文能帮助读者更好地掌握和运用 stream filter 这一强大的功能。

参考资料