Java中如何实现类似C# Linq的OfType<T>泛型类型筛选？

当然能实现类似C#里LINQ OfType<T>的功能！不过因为Java的泛型擦除特性，咱们得做一点小调整才能搞定——先来看你的代码问题，再一步步解决。

基础实现：适配泛型擦除的核心方案 #

你原来的代码里用T.class会直接报错，这是因为Java的泛型是编译时擦除的——编译完之后，T这个类型参数就消失了，运行时根本不知道T具体是什么，所以没法直接拿到它的Class对象。解决办法很简单：显式把目标类型的Class对象作为参数传入方法。

修改你的测试代码如下：

import org.junit.Test;
import java.util.ArrayList;
import java.util.stream.Collectors;

public class GenericFilterTest {

    interface Receives<T> {}

    static class TestMessage {}

    static class TestReceiver implements Receives<TestMessage> {
        private String message;

        public TestReceiver(String message) {
            this.message = message;
        }
    }

    @Test
    public void Testing_stuff() {
        ArrayList<Receives<?>> receivers = new ArrayList<>();
        receivers.add(new TestReceiver("I picked a bad day to give up learning java..."));
        // 调用时传入目标类型的Class对象
        Iterable<Receives<TestMessage>> all = getTheDarnThing(receivers, Receives.class);
    }

    private <T> Iterable<T> getTheDarnThing(ArrayList<?> list, Class<T> targetType) {
        return list.stream()
                .filter(targetType::isInstance) // 安全判断元素是否属于目标类型，比手动写isAssignableFrom更简洁
                .map(targetType::cast) // 用Class的cast方法做类型转换，消除unchecked警告
                .collect(Collectors.toList());
    }
}

进阶：精确匹配泛型接口的类型参数 #

上面的代码能筛选出所有实现Receives接口的对象，但如果你需要严格筛选实现Receives<TestMessage>的实例（而不是所有Receives<?>），就得用反射来获取泛型接口的具体参数了——毕竟泛型擦除后，接口的类型参数信息还保留在类的元数据里：

private <T> Iterable<T> getTheDarnThing(ArrayList<?> list, Class<?> targetInterface, Class<?> genericParamType) {
    return list.stream()
            .filter(item -> {
                // 遍历对象实现的所有泛型接口
                for (var iface : item.getClass().getGenericInterfaces()) {
                    if (iface instanceof ParameterizedType pt) {
                        // 判断是否是目标接口，且泛型参数匹配
                        if (pt.getRawType().equals(targetInterface)) {
                            var actualType = pt.getActualTypeArguments()[0];
                            return actualType.equals(genericParamType);
                        }
                    }
                }
                return false;
            })
            .map(item -> (T) item)
            .collect(Collectors.toList());
}

调用的时候传入接口和泛型参数的Class对象：

Iterable<Receives<TestMessage>> all = getTheDarnThing(receivers, Receives.class, TestMessage.class);

关于“能否获取泛型参数T的具体类型” #

结论是：普通泛型方法里直接不行，但有两种间接方案。

因为Java的泛型擦除机制，编译后T会被替换为Object或其类型上界，运行时没有T的具体类型信息。要拿到它，常用两种方式：

• 显式传递Class参数：就是咱们上面用的方案，调用方法时主动传入目标类型的Class对象，这是最常用、最可靠的方式。
• 通过匿名内部类保留泛型信息：如果是在类级别使用泛型，可以创建匿名内部类让JVM保留泛型参数的元数据，比如：

  abstract class GenericTypeHolder<T> {
      private final Class<T> type;
  
      @SuppressWarnings("unchecked")
      protected GenericTypeHolder() {
          var superType = getClass().getGenericSuperclass();
          if (superType instanceof ParameterizedType pt) {
              this.type = (Class<T>) pt.getActualTypeArguments()[0];
          } else {
              throw new IllegalArgumentException("Holder must be initialized with a parameterized type");
          }
      }
  
      public Class<T> getType() {
          return type;
      }
  }
  
  // 使用示例
  GenericTypeHolder<TestMessage> holder = new GenericTypeHolder<>() {}; // 注意这里的空大括号，创建匿名内部类
  Class<TestMessage> testMsgType = holder.getType();
  

  这种方式适合在类中长期保留泛型类型信息，但在普通方法里实用性不高。

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