Java Stream多条件优先级查找：避免“Stream已操作或关闭”异常

Stream<String> stream0 = Stream.of("a", "b", "c", "d");
Stream<String> stream1 = Stream.of("b", "c", "d", "a");
Stream<String> stream2 = Stream.of("b", "c", "d", "e");
Stream<String> stream3 = Stream.of("d", "e", "f", "g");

// 预期结果：
// findBestValue(stream0); // 应该返回 "a"
// findBestValue(stream1); // 应该返回 "a"
// findBestValue(stream2); // 应该返回 "b"
// findBestValue(stream3); // 应该返回 null

private static String findBestValue(Stream<String> stream) {
    return stream.filter(str -> str.equals("a"))
            .findFirst()
            .orElse(stream.filter(str -> str.equals("b")) // 这里会出错
                    .findFirst()
                    .orElse(stream.filter(str -> str.equals("c"))
                            .findFirst()
                            .orElse(null))
            );
}

import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Objects;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class StreamPrioritySearch {

    /**
     * 从Stream中查找第一个匹配指定优先级键值的元素。
     *
     * @param stream 待处理的Stream。
     * @param key1   最高优先级键。
     * @param key2   次高优先级键。
     * @param key3   第三优先级键。
     * @param <T>    Stream中元素的类型。
     * @return 匹配到的第一个元素，如果都没有匹配则返回null。
     */
    private static <T> T findBestValue(Stream<T> stream, T key1, T key2, T key3) {
        // 1. 将Stream中的所有元素收集到LinkedHashMap中。
        //    Function.identity() 作为键和值，表示元素本身。
        //    (l, r) -> l 用于处理重复键，保留第一个遇到的值。
        //    LinkedHashMap::new 确保保持插入顺序。
        Map<T, T> map = stream.collect(Collectors.toMap(
            Function.identity(), // 元素作为键
            Function.identity(), // 元素作为值
            (l, r) -> l,         // 合并函数：如果键重复，保留第一个遇到的值
            LinkedHashMap::new   // 使用LinkedHashMap保持插入顺序
        ));

        // 2. 遍历优先级键，从map中查找对应的值。
        //    创建一个包含所有优先级键的Stream。
        //    map(map::get) 将键映射到map中的值（如果存在）。
        //    filter(Objects::nonNull) 过滤掉map中不存在的键（即返回null的情况）。
        //    findFirst() 找到第一个非null的值。
        //    orElse(null) 如果所有优先级键在map中都不存在，则返回null。
        return Stream.of(map.get(key1), map.get(key2), map.get(key3))
            .filter(Objects::nonNull)
            .findFirst()
            .orElse(null);
    }

    // 主方法用于测试
    public static void main(String[] args) {
        Stream<String> stream1 = Stream.of("a", "b", "c", "d");
        Stream<String> stream2 = Stream.of("b", "c", "d", "e");
        Stream<String> stream3 = Stream.of("d", "e", "f", "g");

        System.out.println("Stream1 (a,b,c): " + findBestValue(stream1, "a", "b", "c")); // 预期: a
        System.out.println("Stream2 (a,b,c): " + findBestValue(stream2, "a", "b", "c")); // 预期: b
        System.out.println("Stream3 (a,b,c): " + findBestValue(stream3, "a", "b", "c")); // 预期: null

        // 注意：Stream一旦被消费就不能再用，所以每次测试都需要新的Stream实例
        System.out.println("Stream0 (a,b,c): " + findBestValue(Stream.of("a", "b", "c", "d"), "a", "b", "c")); // 预期: a
        System.out.println("Stream1 (b,a,c): " + findBestValue(Stream.of("b", "c", "d", "a"), "b", "a", "c")); // 预期: b (因为b优先级更高)
    }
}

import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Objects;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class StreamPrioritySearchOptimized {

    /**
     * 从Stream中查找第一个匹配指定优先级键值的元素。
     *
     * @param stream 待处理的Stream。
     * @param keys   一个或多个优先级键，按顺序排列。
     * @param <T>    Stream中元素的类型。
     * @return 匹配到的第一个元素，如果都没有匹配则返回null。
     */
    private static <T> T findBestValue(Stream<T> stream, T... keys) {
        // 1. 将Stream中的所有元素收集到LinkedHashMap中。
        Map<T, T> map = stream.collect(Collectors.toMap(
            Function.identity(),
            Function.identity(),
            (l, r) -> l,
            LinkedHashMap::new
        ));

        // 2. 遍历优先级键，从map中查找对应的值。
        //    Arrays.stream(keys) 创建一个包含所有优先级键的Stream。
        //    map(map::get) 将键映射到map中的值。
        //    filter(Objects::nonNull) 过滤掉map中不存在的键。
        //    findFirst() 找到第一个非null的值。
        //    orElse(null) 如果所有优先级键在map中都不存在，则返回null。
        return Arrays.stream(keys)
            .map(map::get)
            .filter(Objects::nonNull)
            .findFirst()
            .orElse(null);
    }

    // 主方法用于测试
    public static void main(String[] args) {
        // 注意：Stream一旦被消费就不能再用，所以每次测试都需要新的Stream实例
        System.out.println("Stream0 (a,b,c): " + findBestValue(Stream.of("a", "b", "c", "d"), "a", "b", "c")); // 预期: a
        System.out.println("Stream1 (a,b,c): " + findBestValue(Stream.of("b", "c", "d", "a"), "a", "b", "c")); // 预期: a
        System.out.println("Stream2 (a,b,c): " + findBestValue(Stream.of("b", "c", "d", "e"), "a", "b", "c")); // 预期: b
        System.out.println("Stream3 (a,b,c): " + findBestValue(Stream.of("d", "e", "f", "g"), "a", "b", "c")); // 预期: null
        System.out.println("Stream4 (e,f,g): " + findBestValue(Stream.of("d", "e", "f", "g"), "e", "f", "g")); // 预期: e
        System.out.println("Stream5 (z,y,x): " + findBestValue(Stream.of("d", "e", "f", "g"), "z", "y", "x")); // 预期: null
    }
}

Stream0 (a,b,c): a
Stream1 (a,b,c): a
Stream2 (a,b,c): b
Stream3 (a,b,c): null
Stream4 (e,f,g): e
Stream5 (z,y,x): null