如何为返回带泛型的Function的方法声明泛型？

先直接给你修正后的可行方案，再一步步拆解问题出在哪：

核心问题分析 #

你的代码主要存在三个关键问题：

1. 缺少方法级泛型声明：matchWith方法使用了T和R两个泛型，但没有在方法上显式声明，编译器无法识别这两个类型的含义。
2. Function参数与调用方式不匹配：你返回的Function<SimpleEntry<T, R>[], R>要求传入数组，但调用时直接传了多个SimpleEntry实例——Java不会自动把多个参数装箱成数组传给Function.apply()（因为apply只接受单个参数）。
3. 空指针风险：entry.getKey().equals(match)如果match或entry.getKey()为null，会直接抛出空指针异常。

方案1：修正原方法，使用标准Function接口 #

如果坚持用JDK自带的Function，需要显式把参数包装成数组，同时补上泛型声明：

import java.util.AbstractMap.SimpleEntry;
import java.util.Map.Entry;
import java.util.Objects;
import java.util.function.Function;
import java.util.stream.Stream;

public class MatchHandler {
    // 必须在方法前声明<T, R>，表示这是方法级的泛型参数
    public <T, R> Function<SimpleEntry<T, R>[], R> matchWith(T match) {
        return functions -> Stream.of(functions)
            // 用Objects.equals避免空指针
            .filter(entry -> Objects.equals(entry.getKey(), match))
            .findFirst()
            .map(Entry::getValue)
            .orElse(null);
    }

    // 示例枚举
    public enum Type { A, B }

    public static void main(String[] args) {
        MatchHandler handler = new MatchHandler();
        // 调用时显式包装成数组
        final String value = handler.matchWith(Type.B).apply(
            new SimpleEntry[]{
                new SimpleEntry<>(Type.A, "Type A matches"),
                new SimpleEntry<>(Type.B, "Type B matches")
            }
        );
        System.out.println(value); // 输出：Type B matches
    }
}

方案2：自定义函数式接口，支持可变参数调用 #

如果想让调用更简洁（不用手动包装数组），可以自定义一个支持可变参数的函数式接口，这样调用时直接传多个SimpleEntry实例即可：

import java.util.AbstractMap.SimpleEntry;
import java.util.Map.Entry;
import java.util.Objects;
import java.util.stream.Stream;

// 自定义函数式接口，用可变参数接收匹配项
@FunctionalInterface
interface MatchFunction<T, R> {
    R apply(SimpleEntry<T, R>... entries);
}

public class MatchHandler {
    // 返回自定义的MatchFunction，泛型声明依然不能少
    public <T, R> MatchFunction<T, R> matchWith(T match) {
        return entries -> Stream.of(entries)
            .filter(entry -> Objects.equals(entry.getKey(), match))
            .findFirst()
            .map(Entry::getValue)
            .orElse(null);
    }

    public enum Type { A, B }

    public static void main(String[] args) {
        MatchHandler handler = new MatchHandler();
        // 直接传多个参数，无需包装数组
        final String value = handler.matchWith(Type.B).apply(
            new SimpleEntry<>(Type.A, "Type A matches"),
            new SimpleEntry<>(Type.B, "Type B matches")
        );
        System.out.println(value); // 输出：Type B matches
    }
}

换成Pair的实现方式 #

如果你想改用Pair<T, R>（比如Apache Commons或JavaFX的Pair），只需要替换掉SimpleEntry即可，泛型声明逻辑完全一致：

import org.apache.commons.lang3.tuple.Pair;
import java.util.Objects;
import java.util.stream.Stream;

@FunctionalInterface
interface MatchFunction<T, R> {
    R apply(Pair<T, R>... entries);
}

public class MatchHandler {
    public <T, R> MatchFunction<T, R> matchWith(T match) {
        return entries -> Stream.of(entries)
            .filter(pair -> Objects.equals(pair.getKey(), match))
            .findFirst()
            .map(Pair::getValue)
            .orElse(null);
    }

    public enum Type { A, B }

    public static void main(String[] args) {
        MatchHandler handler = new MatchHandler();
        final String value = handler.matchWith(Type.B).apply(
            Pair.of(Type.A, "Type A matches"),
            Pair.of(Type.B, "Type B matches")
        );
        System.out.println(value);
    }
}

关于泛型声明的关键说明 #

为什么要在方法上写<T, R>？这是方法级泛型声明，表示这个方法是通用的，适用于任意类型的匹配键（T）和返回值（R）。调用时编译器会根据你传入的参数自动推断出T和R的具体类型（比如上面的例子中，T是Type枚举，R是String）。

内容的提问来源于stack exchange，提问作者Gabriel Rohden