Java Stream 高级过滤技巧：基于映射值保留原始对象-java教程-PHP中文网

Java Stream 高级过滤技巧：基于映射值保留原始对象

聖光之護

发布： 2025-10-08 11:34:01

原创

589人浏览过

java stream 高级过滤技巧：基于映射值保留原始对象

本教程探讨如何在Java Stream中根据对象的某个属性值进行过滤，同时确保过滤结果仍包含原始的完整对象。文章将介绍两种主要方法：一种是使用标准的filter操作结合Lambda表达式，适用于多数场景；另一种是利用Java 16引入的Stream#mapMulti方法，它提供了更灵活的条件判断和元素发射机制，尤其适用于复杂过滤逻辑或需要性能优化的场景。

在Java Stream API中，我们经常需要对对象集合进行过滤操作。一个常见的需求是，根据对象的某个特定属性（例如，Animal对象的color属性）来筛选流，但最终过滤出的结果仍然是完整的原始对象（即Animal对象本身），而不是该属性的值。

例如，我们有一个Animal对象的流animalStream，希望筛选出所有颜色为绿色的动物。直观上可能会想到以下两种方式：

直接使用filter与方法引用：
```
Stream<Animal> swimmingAnimalStream = animalStream
    .filter(Animal::canSwim); // 过滤所有会游泳的动物
```
登录后复制
这种方式简单明了，当过滤条件可以直接通过方法引用表达时非常高效。

立即学习“Java免费学习笔记（深入）”；
使用filter与Lambda表达式：
```
Stream<Animal> greenAnimals = animalStream
    .filter(animal -> animal.getColor().equals(Colors.GREEN)); // 过滤所有颜色为绿色的动物
```
登录后复制
当过滤条件稍微复杂，需要访问对象内部属性并进行比较时，Lambda表达式提供了极大的灵活性。

然而，有时开发者可能希望在过滤前先“映射”出需要判断的属性，然后再进行过滤，但又不想丢失原始对象的信息。例如，以下操作虽然可以过滤出绿色，但最终流中只剩下颜色信息，而非原始的Animal对象：

animalStream
    .map(Animal::getColor) // 将Animal映射为Colors
    .filter(Colors.GREEN::equals); // 过滤颜色为绿色的Colors，结果流为Stream<Colors>

登录后复制

这种方式会改变流中元素的类型，不符合“保留原始完整对象”的需求。

为了解决这一问题，同时避免提取辅助方法，Java Stream API提供了多种策略。

方案一：直接使用Stream#filter结合Lambda表达式（推荐用于简单场景）

对于大多数基于对象内部属性进行过滤的需求，最简洁、最符合Stream声明式风格的解决方案是直接在filter操作中使用Lambda表达式。这种方法将属性的获取和条件的判断逻辑封装在一个Lambda中，确保了流的类型不变。

示例代码：

巧文书

巧文书是一款AI写标书、AI写方案的产品。通过自研的先进AI大模型，精准解析招标文件，智能生成投标内容。

查看详情

import java.util.List;
import java.util.stream.Stream;

// 假设有Animal类和Colors枚举
class Animal {
    enum Colors { GREEN, BLUE, RED }
    private Colors color;
    private String name;
    // ... 构造函数, getter等
    public Colors getColor() { return color; }
    public String getName() { return name; }
    public Animal(String name, Colors color) {
        this.name = name;
        this.color = color;
    }
    @Override
    public String toString() {
        return "Animal{name='" + name + "', color=" + color + '}';
    }
}

public class StreamFilterExample {
    public static void main(String[] args) {
        List<Animal> animals = List.of(
            new Animal("Frog", Animal.Colors.GREEN),
            new Animal("Parrot", Animal.Colors.BLUE),
            new Animal("Chameleon", Animal.Colors.GREEN),
            new Animal("Crab", Animal.Colors.RED)
        );

        Stream<Animal> animalStream = animals.stream();

        // 过滤颜色为绿色的动物，并保留原始Animal对象
        Stream<Animal> greenAnimalsStream = animalStream
            .filter(animal -> Animal.Colors.GREEN.equals(animal.getColor()));

        greenAnimalsStream.forEach(System.out::println);
        // 输出:
        // Animal{name='Frog', color=GREEN}
        // Animal{name='Chameleon', color=GREEN}
    }
}

登录后复制

优点：

简洁易读：代码逻辑清晰，一眼就能看出过滤的条件。
符合Stream风格：完全遵循Stream API的声明式编程范式。
无需额外库：使用Java标准库即可实现。

适用场景： 当过滤条件可以通过一个简单的Lambda表达式直接访问对象属性并进行判断时，此方法是首选。

方案二：利用Stream#mapMulti实现灵活过滤（Java 16+）

对于更复杂、需要精细控制元素发射，或者希望在单个中间操作中完成映射和过滤的场景，Java 16引入的Stream#mapMulti提供了一个强大的替代方案。mapMulti允许你根据任意逻辑，将输入流中的每个元素转换为零个、一个或多个输出元素。这使得它非常适合实现条件性地“接受”或“拒绝”原始对象的需求。

mapMulti方法接收一个BiConsumer<T, Consumer<R>>作为参数。T是输入流的元素类型，R是输出流的元素类型。在BiConsumer的实现中，你可以通过第二个参数Consumer<R>来决定是否以及如何将元素发射到下游流。

示例代码：

import java.util.List;
import java.util.stream.Stream;
import java.util.Optional;

// 假设有Animal类，并增加getMother方法
class Animal {
    enum Colors { GREEN, BLUE, RED }
    private Colors color;
    private String name;
    private Optional<Animal> mother; // 假设动物可能有母亲

    public Animal(String name, Colors color) {
        this(name, color, Optional.empty());
    }
    public Animal(String name, Colors color, Optional<Animal> mother) {
        this.name = name;
        this.color = color;
        this.mother = mother;
    }

    public Colors getColor() { return color; }
    public Optional<Animal> getMother() { return mother; }
    public String getName() { return name; }

    @Override
    public String toString() {
        return "Animal{name='" + name + "', color=" + color + ", hasMother=" + mother.isPresent() + '}';
    }
}

public class StreamMapMultiFilterExample {
    public static void main(String[] args) {
        Animal motherAnimal = new Animal("Mama", Animal.Colors.BLUE);
        List<Animal> animals = List.of(
            new Animal("Frog", Animal.Colors.GREEN),
            new Animal("Parrot", Animal.Colors.BLUE),
            new Animal("Chameleon", Animal.Colors.GREEN, Optional.of(motherAnimal)),
            new Animal("Crab", Animal.Colors.RED)
        );

        Stream<Animal> animalStream = animals.stream();

        // 使用mapMulti过滤颜色为绿色的动物
        Stream<Animal> greenAnimalsMapMultiStream = animalStream
            .mapMulti((animal, consumer) -> {
                if (Animal.Colors.GREEN.equals(animal.getColor())) { // 条件判断
                    consumer.accept(animal); // 如果满足条件，则将原始Animal对象发射到下游
                }
            });

        greenAnimalsMapMultiStream.forEach(System.out::println);
        // 输出:
        // Animal{name='Frog', color=GREEN, hasMother=false}
        // Animal{name='Chameleon', color=GREEN, hasMother=true}

        System.out.println("\n--- 过滤有母亲的动物 ---");
        Stream<Animal> animalWithMotherStream = animals.stream()
            .mapMulti((animal, consumer) -> {
                if (animal.getMother().isPresent()) { // 检查是否有母亲
                    consumer.accept(animal); // 如果有，发射原始Animal对象
                }
            });
        animalWithMotherStream.forEach(System.out::println);
        // 输出:
        // Animal{name='Chameleon', color=GREEN, hasMother=true}
    }
}

登录后复制

Stream#mapMulti的优点：

性能优势：在某些情况下，mapMulti可以避免map和filter等多个中间操作链带来的额外开销，因为它将转换和过滤逻辑合并到单个遍历中。
高度灵活性：
- 条件发射：可以根据任意复杂的条件决定是否发射元素，完美实现过滤效果。
- 一对多转换：consumer.accept()可以被调用多次，允许一个输入元素产生多个输出元素。这对于需要将一个复杂对象分解为多个子元素，或根据不同条件生成不同输出的场景非常有用。
- 保持原始对象：通过consumer.accept(animal)，可以轻松地将原始对象传递到下游流，满足了核心需求。

Stream#mapMulti的缺点：

声明式风格减弱：与filter的简洁声明式相比，mapMulti内部的BiConsumer逻辑更偏向命令式，可能导致代码可读性略有下降，尤其对于简单的过滤任务。
版本限制：仅适用于Java 16及更高版本。

使用场景：

当需要结合映射和过滤逻辑，并希望在一个中间操作中完成，以优化性能时。
当过滤条件非常复杂，或者需要根据条件一个输入元素生成零个、一个或多个输出元素时。
当希望避免链式map().filter()操作可能引入的细微性能损耗时。

总结

在Java Stream中根据对象的某个属性进行过滤并保留原始对象，主要有两种策略：

对于简单直接的过滤条件：推荐使用Stream#filter结合Lambda表达式。它简洁、易读，且符合Stream的声明式风格，适用于绝大多数场景。
对于Java 16及以上版本，且面临复杂过滤逻辑、性能优化需求或需要一对多转换的场景：Stream#mapMulti提供了一个强大且灵活的解决方案。它允许在单个中间操作中实现精细的元素控制和条件发射，但代码风格会略微偏向命令式。

选择哪种方法取决于您的具体需求、Java版本以及对代码可读性和性能优化的权衡。对于日常开发中的常规过滤任务，filter操作通常是最佳选择。

以上就是Java Stream 高级过滤技巧：基于映射值保留原始对象的详细内容，更多请关注php中文网其它相关文章！