Java：Instanceof 和泛型

Question

在查看值索引的通用数据结构之前，我想看看它是否是 this 已参数化的类型的实例。

但是当我这样做时 Eclipse 会抱怨：

@Override
public int indexOf(Object arg0) {
    if (!(arg0 instanceof E)) {
        return -1;
    }

这是错误消息：

无法对类型参数 E 执行instanceof 检查。请使用其擦除对象，因为泛型类型信息将在运行时被擦除

更好的方法是什么？

Answer 1

错误消息说明了一切。在运行时，类型消失了，无法检查它。

您可以通过为您的对象创建一个工厂来捕获它，如下所示：

public static <T> MyObject<T> createMyObject(Class<T> type) {
    return new MyObject<T>(type);
}

然后在对象的构造函数中存储该类型，因此变量，以便您的方法可以如下所示：

if (arg0 != null && !(this.type.isAssignableFrom(arg0.getClass())) {
    return -1;
}

Answer 2

使用泛型进行运行时类型检查的两个选项：

选项 1 - 破坏构造函数

让我们假设您正在重写 indexOf(...)，并且您想要检查类型只是为了性能，以节省自己迭代整个收藏。

制作一个像这样的肮脏的构造函数：

public MyCollection<T>(Class<T> t) {

    this.t = t;
}

然后你可以使用 isAssignableFrom 检查类型。

public int indexOf(Object o) {

    if (
        o != null &&

        !t.isAssignableFrom(o.getClass())

    ) return -1;

//...

每次实例化对象时，您都必须重复自己：

new MyCollection<Apples>(Apples.class);

您可能会认为它不值得。在ArrayList.indexOf(...)，它们不检查类型是否匹配。

选项 2 - 让它失败

如果您需要使用需要未知类型的抽象方法，那么您真正想要的就是编译器停止抱怨 instanceof。如果你有这样的方法：

protected abstract void abstractMethod(T element);

你可以这样使用它：

public int indexOf(Object o) {

    try {

        abstractMethod((T) o);

    } catch (ClassCastException e) {

//...

你将对象转换为 T （你的泛型类型），只是为了欺骗编译器。 您的转换在运行时不执行任何操作，但您仍然会当您尝试将错误类型的对象传递到抽象方法时，会出现 ClassCastException。

注意 1：如果您在抽象方法中执行额外的未经检查的强制转换，您的 ClassCastExceptions 将在这里被捕获。这可能是好事，也可能是坏事，所以要三思而后行。

注意2：使用instanceof时，您将获得免费的空检查。由于您无法使用它，因此您可能需要徒手检查是否为 null。

Answer 3

老帖子，但是一种进行通用instanceOf检查的简单方法。

public static <T> boolean isInstanceOf(Class<T> clazz, Class<T> targetClass) {
    return clazz.isInstance(targetClass);
}

Answer 4

如果你的类扩展了一个带有泛型参数的类，你也可以在运行时通过反射获取它，然后使用它进行比较，即

class YourClass extends SomeOtherClass<String>
{

   private Class<?> clazz;

   public Class<?> getParameterizedClass()
   {
      if(clazz == null)
      {
         ParameterizedType pt = (ParameterizedType)this.getClass().getGenericSuperclass();
          clazz = (Class<?>)pt.getActualTypeArguments()[0];
       }
       return clazz;
    }
}

在上面的情况下，在运行时你将从 getParameterizedClass() 获取 String.class，并且它会缓存所以在多次检查时你不会得到任何反射开销。请注意，您可以通过 ParameterizedType.getActualTypeArguments() 方法中的索引获取其他参数化类型。

Answer 5

我遇到了同样的问题，这是我的解决方案（非常谦虚，@george：这次编译并工作......）。

我的探针位于一个实现 Observer 的抽象类中。
Observable 使用可以是任何类型的对象的对象类触发 update(...) 方法。

我只想处理 T 类型的对象

解决方案是将类传递给构造函数，以便能够在运行时比较类型。

public abstract class AbstractOne<T> implements Observer {

  private Class<T> tClass;
    public AbstractOne(Class<T> clazz) {
    tClass = clazz;
  }

  @Override
  public void update(Observable o, Object arg) {
    if (tClass.isInstance(arg)) {
      // Here I am, arg has the type T
      foo((T) arg);
    }
  }

  public abstract foo(T t);

}

对于实现，我们只需将 Class 传递给构造函数

public class OneImpl extends AbstractOne<Rule> {
  public OneImpl() {
    super(Rule.class);
  }

  @Override
  public void foo(Rule t){
  }
}

Answer 6

或者您可能会发现尝试转换为 E 例如
失败。

public int indexOf(Object arg0){
  try{
    E test=(E)arg0;
    return doStuff(test);
  }catch(ClassCastException e){
    return -1;
  }
}

Answer 7

从技术上讲，您不必这样做，这就是泛型的要点，因此您可以进行编译类型检查：

public int indexOf(E arg0) {
   ...
}

但是如果您有类层次结构，则 @Override 可能会成为问题。否则请参阅 Yishai 的回答。

Answer 8

对象的运行时类型是一个相对任意的过滤条件。我建议您不要收藏这些肮脏的东西。这可以通过将集合委托给构造中传递的过滤器来简单地实现。

public interface FilterObject {
     boolean isAllowed(Object obj);
}

public class FilterOptimizedList<E> implements List<E> {
     private final FilterObject filter;
     ...
     public FilterOptimizedList(FilterObject filter) {
         if (filter == null) {
             throw NullPointerException();
         }
         this.filter = filter;
     }
     ...
     public int indexOf(Object obj) {
         if (!filter.isAllows(obj)) {
              return -1;
         }
         ...
     }
     ...
}

     final List<String> longStrs = new FilterOptimizedList<String>(
         new FilterObject() { public boolean isAllowed(Object obj) {
             if (obj == null) {
                 return true;
             } else if (obj instanceof String) {
                 String str = (String)str;
                 return str.length() > = 4;
             } else {
                 return false;
             }
         }}
     );

Answer 9

让Java来判断并捕获异常底线。

public class Behaviour<T> {
    public void behave(Object object) {
        T typedObject = null;
        
        try { typedObject = (T) object; }
        catch (ClassCastException ignored) {}
        
        if (null != typedObject) {
            // Do something type-safe with typedObject
        }
    }
}