JavaStream：过滤前映射值保留原对象

珍惜时间，勤奋学习！今天给大家带来《Java Stream：过滤前映射值保留原对象》，正文内容主要涉及到等等，如果你正在学习文章，或者是对文章有疑问，欢迎大家关注我！后面我会持续更新相关内容的，希望都能帮到正在学习的大家！

理解需求：在过滤中保留原始对象

在Java Stream API中，我们经常需要对对象集合进行过滤操作。对于简单的条件，直接使用Stream#filter配合方法引用或Lambda表达式非常直观和高效。例如，过滤出所有能游泳的动物：

Stream<Animal> swimmingAnimalStream = animalStream
    .filter(Animal::canSwim);

或者过滤出所有绿色的动物：

Stream<Animal> greenAnimals = animalStream
    .filter(animal -> animal.getColor().equals(Colors.GREEN));

然而，当过滤条件基于对象的某个属性的派生值，并且我们希望在过滤后仍然保留原始对象时，传统的map和filter组合可能会导致问题。例如，如果先将Animal映射为Color，再进行过滤：

animalStream
    .map(Animal::getColor)
    .filter(Colors.GREEN::equals); // 此时流中只剩下Color信息，原始Animal对象已丢失

这种方式会使流中只剩下颜色信息，而非原始的Animal对象。为了避免这种情况，同时又不希望为每个复杂的过滤条件都提取一个辅助方法，开发者通常会寻求一种更“流式化”的解决方案，例如，期望能有一个类似于filter(Predicate filter, Function mappingFunction)的方法，能够在内部先将对象映射为某个值，再基于这个值进行过滤，但最终流中仍保留原始对象。

Java 16+ 解决方案：使用 Stream#mapMulti

从Java 16开始，Stream接口引入了一个强大的新方法mapMulti，它提供了一种灵活的方式来处理此类需求。mapMulti允许我们在处理每个元素时，根据任意逻辑决定是否将零个、一个或多个元素放入下游流中。这使得它非常适合实现“在过滤前映射值并保留原始对象”的场景。

Stream#mapMulti的签名如下：

<R> Stream<R> mapMulti(BiConsumer<? super T, ? super Consumer<R>> mapper)

其中，mapper是一个BiConsumer，它接收当前流中的元素T和下游流的Consumer。通过调用Consumer的accept方法，我们可以将元素传递到下游流。

使用mapMulti来实现我们最初的需求，即过滤出绿色的动物但保留Animal对象：

import java.util.stream.Stream;
import java.util.function.Consumer; // 导入Consumer

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

public class StreamFilterExample {
    public static void main(String[] args) {
        Stream<Animal> animalStream = Stream.of(
            new Animal("Lion", Colors.RED),
            new Animal("Frog", Colors.GREEN),
            new Animal("Parrot", Colors.BLUE),
            new Animal("Snake", Colors.GREEN)
        );

        Stream<Animal> greenAnimals = animalStream
            .mapMulti((animal, consumer) -> {
                // 在这里进行映射和过滤逻辑
                if (Colors.GREEN.equals(animal.getColor())) { // 条件判断
                    consumer.accept(animal); // 如果满足条件，将原始animal对象放入下游流
                }
            });

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

mapMulti的优势：

1. 性能优化： 相较于map().filter()组合，mapMulti可以在一个操作中完成映射和过滤，减少了中间流的创建和遍历开销，在某些场景下可能带来性能提升。
2. 高度灵活性： Consumer#accept可以被调用零次、一次或多次。这意味着mapMulti不仅可以用于过滤（零次或一次），还可以实现flatMap类似的功能（多次调用），甚至在内部根据复杂逻辑生成新的元素。例如，如果一个动物有多个颜色，你可以在满足条件时将同一个动物对象多次accept到流中，或者根据动物的不同属性生成不同的派生对象。
3. 避免额外方法提取： 它允许将复杂的判断逻辑直接内联到Stream操作中，而无需为每个特定过滤条件创建新的辅助方法。

mapMulti的注意事项：

1. 命令式风格： 相比于filter或map的声明式风格，mapMulti内部的Lambda表达式更偏向命令式编程，这可能会让代码的可读性略有下降，尤其是在逻辑复杂时。
2. 适用场景： 对于简单的过滤条件，直接使用filter配合Lambda表达式通常更为简洁明了。mapMulti更适用于那些需要根据复杂条件决定是否传递元素，或者需要将一个元素转换为零个、一个或多个元素的场景。

传统与简洁：Stream#filter 的灵活应用

对于Java 16之前的版本，或者即使在Java 16及更高版本中，如果需求相对简单，最直接且推荐的方式仍然是使用Stream#filter，并在其Lambda表达式中包含基于映射值的判断逻辑。这种方法虽然没有提供像期望中filter(Predicate, Function)那样的语法糖，但它清晰、声明性强，且易于理解。

import java.util.stream.Stream;

// 假设Animal和Colors类已定义
// ...

public class StreamFilterTraditionalExample {
    public static void main(String[] args) {
        Stream<Animal> animalStream = Stream.of(
            new Animal("Lion", Colors.RED),
            new Animal("Frog", Colors.GREEN),
            new Animal("Parrot", Colors.BLUE),
            new Animal("Snake", Colors.GREEN)
        );

        // 直接在filter的Lambda表达式中进行条件判断
        Stream<Animal> greenAnimals = animalStream
             .filter(animal -> Colors.GREEN.equals(animal.getColor())); // 映射并判断，但保留原始对象

        greenAnimals.forEach(System.out::println);
        // 输出与mapMulti示例相同
    }
}

这种方法的优点在于：

1. 简洁性： 对于简单的映射-过滤组合，Lambda表达式足够简洁。
2. 声明性： 它清晰地表达了“过滤出满足特定条件的元素”的意图。
3. 广泛兼容性： 适用于所有Java 8及以上版本。

总结与选择建议

在Java Stream中实现基于映射值进行过滤并保留原始对象的需求，我们可以根据Java版本、逻辑复杂度和个人偏好进行选择：

• 对于Java 16及更高版本，且过滤逻辑复杂、需要高性能优化或涉及一个元素生成多个下游元素的情况，Stream#mapMulti是一个强大且灵活的选择。它允许你将复杂的判断和转换逻辑封装在一个操作中，有效减少中间流的开销。
• 对于所有Java版本，特别是当过滤条件相对简单，或者追求代码的声明性和简洁性时，直接在Stream#filter的Lambda表达式中包含映射和判断逻辑，仍然是最推荐和最清晰的方式。它避免了引入额外的复杂性，并保持了Stream API的声明式风格。

选择哪种方法取决于具体的场景。理解它们各自的优缺点，能够帮助开发者编写出更高效、更可维护的Java Stream代码。

终于介绍完啦！小伙伴们，这篇关于《JavaStream：过滤前映射值保留原对象》的介绍应该让你收获多多了吧！欢迎大家收藏或分享给更多需要学习的朋友吧~golang学习网公众号也会发布文章相关知识，快来关注吧！