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（您的泛型类型），只是为了欺骗编译器。 Your cast does nothing at runtime，但是当您尝试将错误类型的对象传递给抽象方法时，仍会遇到ClassCastException。

注意1：如果您在抽象方法中执行其他未经检查的强制转换，则会在此处捕获ClassCastExceptions。这可能是好事也可能是坏事，所以请仔细考虑。

注2：You get a free null check when you use instanceof。由于您无法使用它，您可能需要赤手检查是否为空。

Answer 3

旧帖子，但是通用实例检查的简单方法。

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：这次编译和工作......）。

我的probem在一个实现Observer的抽象类中。 Observable使用Object类触发方法update（...），Object类可以是任何类型的Object。

我只想处理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
        }
    }
}

Java：Instanceof和Generics

9 个答案: