优雅地链式调用 Optional.ifPresent() 中的多个操作

animalService.getAllAnimals().findFirst()
    .ifPresent(Animal::drink) // 假设这里可以返回Optional
    .ifPresent(Animal::eat);

Optional<Animal> optionalAnimal = animalService.getAllAnimals().findFirst();
optionalAnimal.ifPresent(Animal::eat);
optionalAnimal.ifPresent(Animal::drink);

animalService.getAllAnimals().findFirst()
    .ifPresent(animal -> {
        animal.drink();
        animal.eat();
    });

// 假设 Animal::drink 返回 Animal 实例本身
animalService.getAllAnimals().findFirst()
    .map(Animal::drink) // 执行 drink 操作，并返回 Animal 实例的 Optional
    .ifPresent(Animal::eat); // 对返回的 Animal 实例执行 eat 操作

import java.util.Arrays;
import java.util.function.Consumer;

public class OptionalChainingUtils {

    /**
     * 组合多个 Consumer，形成一个按顺序执行所有操作的 Consumer。
     * 如果 Optional 存在值，这个组合的 Consumer 将会按传入顺序执行所有操作。
     *
     * @param first 第一个要执行的 Consumer。
     * @param others 其他要按顺序执行的 Consumer。
     * @param <T> Consumer 接受的类型。
     * @return 一个组合的 Consumer，它会按顺序执行所有传入的 Consumer 操作。
     */
    @SafeVarargs
    public static <T> Consumer<T> combine(Consumer<T> first, Consumer<T>... others) {
        // 使用 Stream.reduce 将所有的 Consumer 通过 andThen 组合起来
        // first 作为初始值，后续的 Consumer 依次通过 andThen 连接
        return Arrays.stream(others).reduce(first, Consumer::andThen);
    }
}

import java.util.Optional;
import java.util.function.Consumer;

// 假设 Animal 类和 animalService 已经定义
class Animal {
    void eat() { System.out.println("Animal is eating."); }
    void drink() { System.out.println("Animal is drinking."); }
    void sleep() { System.out.println("Animal is sleeping."); }
}

class AnimalService {
    public Optional<Animal> getAllAnimals() {
        // 模拟返回一个包含值的 Optional
        return Optional.of(new Animal());
        // 模拟返回一个空的 Optional
        // return Optional.empty();
    }
}

public class Main {
    public static void main(String[] args) {
        AnimalService animalService = new AnimalService();

        // 使用 combine 方法优雅地链式调用多个操作
        animalService.getAllAnimals()
            .ifPresent(OptionalChainingUtils.combine(
                Animal::drink, // 第一个操作
                Animal::eat,   // 第二个操作
                Animal::sleep  // 第三个操作
            ));

        // 当 Optional 为空时，没有任何操作会被执行
        animalService.getAllAnimals().filter(a -> false) // 模拟一个空的Optional
            .ifPresent(OptionalChainingUtils.combine(
                Animal::drink,
                Animal::eat
            ));
    }
}

Animal is drinking.
Animal is eating.
Animal is sleeping.