Java Instanceof and Generics

Question

Before I look through my generic data structure for a value s index  I d like to see if it is even an instance of the type this has been parametrized to   But Eclipse complains when I do this    Override public int indexOf Object arg0        if    arg0 instanceof E             return -1          This is the error message      Cannot perform instanceof check against type parameter E  Use instead its erasure Object since generic type information will be erased at runtime   What is the better way to do it

User · Answer

Two options for runtime type checking with generics:

Option 1 - Corrupt your constructor

Let's assume you are overriding indexOf(...), and you want to check the type just for performance, to save yourself iterating the entire collection.

Make a filthy constructor like this:

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

    this.t = t;
}

Then you can use isAssignableFrom to check the type.

public int indexOf(Object o) {

    if (
        o != null &&

        !t.isAssignableFrom(o.getClass())

    ) return -1;

//...

Each time you instantiate your object you would have to repeat yourself:

new MyCollection<Apples>(Apples.class);

You might decide it isn't worth it. In the implementation of ArrayList.indexOf(...), they do not check that the type matches.

Option 2 - Let it fail

If you need to use an abstract method that requires your unknown type, then all you really want is for the compiler to stop crying about instanceof. If you have a method like this:

protected abstract void abstractMethod(T element);

You can use it like this:

public int indexOf(Object o) {

    try {

        abstractMethod((T) o);

    } catch (ClassCastException e) {

//...

You are casting the object to T (your generic type), just to fool the compiler. Your cast does nothing at runtime, but you will still get a ClassCastException when you try to pass the wrong type of object into your abstract method.

NOTE 1: If you are doing additional unchecked casts in your abstract method, your ClassCastExceptions will get caught here. That could be good or bad, so think it through.

NOTE 2: You get a free null check when you use instanceof. Since you can't use it, you may need to check for null with your bare hands.

User · Answer

The runtime type of the object is a relatively arbitrary condition to filter on  I suggest keeping such muckiness away from your collection  This is simply achieved by having your collection delegate to a filter passed in a construction   public interface FilterObject        boolean isAllowed Object obj      public class FilterOptimizedList lt E gt  implements List lt E gt         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 lt String gt  longStrs   new FilterOptimizedList lt String gt            new FilterObject     public boolean isAllowed Object obj                 if  obj    null                     return true                 else if  obj instanceof String                     String str    String str                   return str length    gt    4                 else                    return false

User · Answer

Provided your class extends a class with a generic parameter  you can also get this at runtime via reflection  and then use that for comparison  i e   class YourClass extends SomeOtherClass lt String gt        private Class lt   gt  clazz      public Class lt   gt  getParameterizedClass              if clazz    null                   ParameterizedType pt    ParameterizedType this getClass   getGenericSuperclass              clazz    Class lt   gt  pt getActualTypeArguments   0                   return clazz            In the case above  at runtime you will get String class from getParameterizedClass    and it caches so you don t get any reflection overhead upon multiple checks   Note that you can get the other parameterized types by index from the ParameterizedType getActualTypeArguments   method

User · Answer

The error message says it all  At runtime  the type is gone  there is no way to check for it   You could catch it by making a factory for your object like this    public static  lt T gt  MyObject lt T gt  createMyObject Class lt T gt  type        return new MyObject lt T gt  type        And then in the object s constructor store that type  so variable so that your method could look like this           if  arg0    null  amp  amp    this type isAssignableFrom arg0 getClass                           return -1

User · Answer

Old post  but a simple way to do generic instanceOf checking   public static  lt T gt  boolean isInstanceOf Class lt T gt  clazz  Class lt T gt  targetClass        return clazz isInstance targetClass

User · Answer

Or you could catch a failed attempt to cast into E eg   public int indexOf Object arg0     try      E test  E arg0      return doStuff test      catch ClassCastException e       return -1

User · Answer

I had the same problem and here is my solution  very humble   george  this time compiling AND working        My probem was inside an abstract class that implements Observer  The Observable fires method update      with Object class that can be any kind of Object   I only want to handler Objects of type T   The solution is to pass the class to the constructor in order to be able to compare types at runtime   public abstract class AbstractOne lt T gt  implements Observer      private Class lt T gt  tClass      public AbstractOne Class lt T gt  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        For the implementation we just have to pass the Class to the constructor  public class OneImpl extends AbstractOne lt Rule gt      public OneImpl         super Rule class           Override   public void foo Rule t

User · Answer

Technically you shouldn t have to  that s the point of generics  so you can do compile-type checking   public int indexOf E arg0               but then the  Override may be a problem if you have a class hierarchy  Otherwise see Yishai s answer

[java] Java: Instanceof and Generics

Examples related to java

Examples related to generics

Examples related to instanceof

Examples related to typechecking