解决 Java Stream 中 Predicate 的泛型类型不匹配问题

在 Java Stream API 的使用过程中，我们可能会遇到由于类型不匹配导致的编译错误。例如，当使用 filter() 方法结合 instanceof 检查时，即使已经筛选出特定类型的元素，Stream 的类型仍然没有改变，这会导致后续的 anyMatch() 方法中 Predicate 的泛型类型不匹配。

问题分析

考虑以下代码片段：

private void func(Object o) {
    Predicate> pred = m -> true;
    if (o instanceof Map && pred.test((Map) o)) {
        // ...pred.test is OK
    } else if (o instanceof Collection && ((Collection) o).stream().filter(i -> i instanceof Map).anyMatch(pred)) {
        // ...anyMatch here gives the above error
    }
}

这段代码尝试在一个 Collection 中筛选出 Map 类型的元素，并使用 anyMatch() 方法判断是否存在满足 Predicate 的元素。然而，由于 filter() 方法的作用是过滤元素，而不是改变 Stream 的类型，因此 stream().filter(i -> i instanceof Map) 返回的仍然是 Stream

解决方案

1. 使用 map 进行类型转换

解决这个问题的一种方法是使用 map() 操作进行类型转换。可以将 Stream 中的元素强制转换为 Map 类型：

private void func(Object o) {
    Predicate> pred = m -> true;
    if (o instanceof Map && pred.test((Map) o)) {
        // ...pred.test is OK
    } else if (o instanceof Collection && ((Collection) o).stream().filter(i -> i instanceof Map).>map(Map.class::cast).anyMatch(pred)) {
        // ...anyMatch now works
    }
}

或者使用更简洁的类型转换：

private void func(Object o) {
    Predicate> pred = m -> true;
    if (o instanceof Map && pred.test((Map) o)) {
        // ...pred.test is OK
    } else if (o instanceof Collection && ((Collection) o).stream().filter(i -> i instanceof Map).map(i -> (Map) i).anyMatch(pred)) {
        // ...anyMatch now works
    }
}

这两种方式都将 Stream

2. 使用 mapMulti 进行模式匹配 (Java 16+)

如果使用的是 Java 16 或更高版本，可以利用 mapMulti() 方法结合模式匹配，将 filter 和 map 操作合并为一步：

private void func(Object o) {
    Predicate> pred = m -> true;
    if (o instanceof Map && pred.test((Map) o)) {
        // ...pred.test is OK
    } else if (o instanceof Collection && ((Collection) o).stream()
            .>mapMulti((i, consumer) -> {
                if (i instanceof Map m) consumer.accept(m);
            })
            .anyMatch(pred)) {
        // ...anyMatch now works
    }
}

mapMulti() 方法接受一个 BiConsumer，用于处理 Stream 中的每个元素。在 BiConsumer 中，使用 instanceof 进行类型判断，如果元素是 Map 类型，则使用 consumer.accept(m) 将其传递给下游的 Stream。

代码示例

以下是一个完整的示例，演示了如何使用 map 和 mapMulti 解决类型不匹配问题：

import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Predicate;

public class StreamPredicateExample {

    private void funcWithMap(Object o) {
        Predicate> pred = m -> true;
        if (o instanceof Map && pred.test((Map) o)) {
            System.out.println("Direct Map test OK");
        } else if (o instanceof Collection) {
            boolean anyMatch = ((Collection) o).stream()
                    .filter(i -> i instanceof Map)
                    .map(i -> (Map) i) // Using map for type conversion
                    .anyMatch(pred);
            System.out.println("Collection with map using map: " + anyMatch);
        }
    }

    private void funcWithMapMulti(Object o) {
        Predicate> pred = m -> true;
        if (o instanceof Map && pred.test((Map) o)) {
            System.out.println("Direct Map test OK");
        } else if (o instanceof Collection) {
            boolean anyMatch = ((Collection) o).stream()
                    .>mapMulti((i, consumer) -> { // Using mapMulti for type conversion and filtering
                        if (i instanceof Map m) consumer.accept(m);
                    })
                    .anyMatch(pred);
            System.out.println("Collection with map using mapMulti: " + anyMatch);
        }
    }

    public static void main(String[] args) {
        StreamPredicateExample example = new StreamPredicateExample();

        Map map = new HashMap<>();
        map.put("key1", 1);
        map.put("key2", 2);

        List