Ensuring that "Object o" parameter is of the same generic type when implementing java interfaces

Question

I am trying to create a hybrid list that uses Binary Search Trees for various functions. The class tries to implement List< E >. To index, these trees use comparison to decide whether data should be placed in the left or right child of the parent. This is done using a Comparator variable set by the Constructor:

private Comparator<E> comparator; // method for ordering the tree

This ensures that type E will be comparable in some way. The problem however is in how the List Interface declared its abstract functions. For example:

public boolean contains(Object o);

Normally, I would assume that the parameter is comparable and then use a recursive lookup method on the tree, but because the parameter is Object, I cannot make that assumption.

I have tried to ensure that it is of type E by doing the following:

if (o instanceof E) {}

but it does not work and gives me this suggestion:

Cannot perform instanceof check against type parameter E. 
Use its erasure Object instead since further generic type information will be erased at runtime

Any ideas on how to solve this?

Edit:

This is how the class is instantiated:

TreeCollection<Integer> c = new TreeCollection<>(
            new Comparator<Integer>() {

                @Override
                public int compare(Integer o1, Integer o2) {
                    return o1.compareTo(o2);
                }

            });

Answer 1

There's no perfect answer for your situation. There's a kind of conflict between the Comparator, where correct use is enforced by compile-time generics, and the .contains() method, whose contract depends on .equals(), which takes any type of object (there is no compile-time constraint), and whose logic must be based on runtime information. This problem is also faced by TreeSet.

The whole point of your data structure is lookup is O(log n), so you cannot go through every element and check; instead, you must go down the binary search tree, by comparing the given value to the elements using the comparator. But since the given element is any type of object, we don't know the comparator can take it. I think the best solution is just to cast it to E and assume that your comparator can take it. If the object is not an instance of E, the comparator will probably throw ClassCastException somehow, and you can just let that exception pass up to the user. TreeSet takes this approach -- the documentation for TreeSet.contains() says that it throws ClassCastException when the specified object cannot be compared with the elements in the set.

Although this makes .contains() less general, it avoids breaking the contract of Collection.contains(), because in the case where someone gives us an object to .contains() that our comparator cannot compare, the correct answer could be true or false according to the contract, but we can't determine that efficiently; so instead of returning something that might be wrong, we throw an exception, which is allowed in the contract.

Answer 2

There's a design pattern in Java called "Heterogeneous Container" that might be useful here.

Basically, erasure and generics was kind of a crappy idea, as you've discovered, so the Heterogeneous Container is a way you can fix it up.

Basically you just pass in a class object of the type you want.

public class MyListTreeSet<E> extends AbstractList<E>
{

   private Class<E> type;
   private TreeSet<E> set;

   public MyListTreeSet( Comparator<? super E> comp, Class<E> type )
   {
      this.type = type;
      set = new TreeSet<>( comp );
   }

Now when you do the contains() method you can test directly whether the parameter is of the correct type.

   @Override
   public boolean contains( Object o )
   {
      if( !type.isInstance( o ) ) return false;
      E e = type.cast( o );
      // e is now the same type as your set and therefore 
      // implements Comparable
      return set.contains( e );  // quickie example
   }

There's ways you can fancy this up, but this is the most basic example.

EDIT:

To instantiate this as you show, you must create a new type (class). However it can be a subtype of your existing class, so no other code besides the creation of the set has to change. If TreeCollection is code you control, then it would be a lot easier to just add the changes to the TreeCollection class directly.

TreeCollection<Integer> c = new NewTreeCollection<>(
        new Comparator<Integer>() {

            @Override
            public int compare(Integer o1, Integer o2) {
                return o1.compareTo(o2);
            }

        }, Integer.class );

The NewTreeCollection follows the same basic pattern as the List I made above, although if TreeCollection inherits from TreeSet then you can remove some of the variables.

public class NewTreeCollection<E> extends TreeCollection<E>
{

   private Class<E> type;
   private TreeSet<E> set;

   public NewTreeCollection( Comparator<? super E> comp, Class<E> type )
   {
      this.type = type;
      set = new TreeSet<>( comp );
   }

   @Override
   public boolean contains( Object o )
   {
      if( !type.isInstance( o ) ) return false;
      E e = type.cast( o );
      // e is now the same type as your set and therefore 
      // implements Comparable
      return set.contains( e );  // quickie example
   }
}

Answer 3

There is a way of obtaining the generic types used in the creation of concrete classes of a given generic class/interface.

eg.

List<Integer> list = new ArrayList<>(); 

Cannot retrieve generic type of list at runtime as it is an instance of ArrayList which is generic and contains no reference to its generic type.

class MyList extends ArrayList<Integer> {}
List<Integer> list1 = new MyList();

MyList is a non-generic and concrete implementation of a generic ArrayList. As such you will be able to use reflections to inspect what that generic type actually is.

Comparator<Integer> cmp = new Comparator<Integer>() {...};

cmp is an anonymous, but non-generic and concrete implementation of the Comparator interface. As such we can determine what generic type it is using.

How to determine the generic type of a concrete sub-class

Comparator<Integer> cmp = new Comparator<Integer>() {
    @Override
    public int compare(Integer x, Integer y) {
        return x.compareTo(y);
    }
};
Type genericType = cmp.getClass().getGenericInterfaces()[0];
// use getGenericSuperclass() if subclassing a class rather than implementing an 
// interface
if (genericType instanceof Class) {
    throw new RuntimeException("Missing type parameter.");
}
Type type = ((ParameterizedType) genericType).getActualTypeArguments()[0];  

Class<?> cls = (Class<?>) type;
boolean is_true = cls.isInstance(1);
boolean is_false = cls.isInstance(1.);