Gen. List of a gen. class with a gen. type of a Comparable ? super C

Question

Hi,
I'm facing a (little ;-)) problem getting my code free of unchecked warnings.
Please consider the following code:
There are two generic classes:
public class AppDbObjectCache<T extends AppDbObject> {
  private List<AppDbObjectCacheIndex<T,?>> indexes;
  // select an object via cache by unique key
  public <C extends Comparable<? super C>> T select(int handle,  C key)  {
    // unchecked warning (won't compile without cast)
    AppDbObjectCacheIndex<T,C> index = (AppDbObjectCacheIndex<T,C>)indexes.get(handle);
}and:
public class AppDbObjectCacheIndex<T extends AppDbObject, C extends Comparable<? super C>> {
}My problem is the wildcard in private List<AppDbObjectCacheIndex<T,?>> indexes
because I need a cast whenever I get an element out of the List and
that cast triggers an unchecked warning.
I tried:
private List<AppDbObjectCacheIndex<T,? extends Comparable<?>>> indexes;but the compiler is right about the fact that a Comparable<?> is
not the same as a C extends Comparable<? super C> and still
insists on a cast.
Then I tried:
private List<AppDbObjectCacheIndex<T,? extends Comparable<? extends ?>>>which is nonsense, of course, but it shows the problem of having two
different wildcards and I have no clue how to express that.
To introduce the second wildcard, i.e. the 'C', I tried:
private <C extends Comparable<? super C>> List<AppDbObjectCacheIndex<T,C> indexes;but the compiler complains about a wrong syntax, because declaring
a generic type is only allowed for classes and methods and not for
variable declarations.
Is there a way to express in the List-declaration that the 2nd type
variable of the List's objects is something that extends a Comparable of a superclass of itself?
Or do I have to live with the casts as with Class.forName() ?
Any idea?
Thanx,
Harald

Answer 1

Ok.
Here is an example stripped down to the very essentials.
We're talking about a typesafe generic cache for persistable objects
(stored in a database in real life, but that doesn't matter in this example).
There are 5 classes:
- the superclass for all such objects. These objects are uniquely
identified by a Long integer, the so-called object-id.
- the sample object class to be cached. Instances of this class are
additionally unique by their name, which is a String.
- the sample class showing how to setup and use the cache.
- the generic cache with the ability for managing any number of unique indexes
- the generic cache index
So far, so good.
The super class of all database objects:
* database object
public class BlaObject {
  private long id;        // unique object id
  public void setId(long id) {
    this.id = id;
  public long getId() {
    return id;
  public BlaObject getFromStorageById(long id)  {
    // whatever is necessary to get it from storage by id ...
    return this;
}The sample object class extended by the unique attribute 'name':
public class BlaExampleObject extends BlaObject {
  private String name;    // unique name
  public void setName(String name)  {
    this.name = name;
  public String getName() {
    return name;
  public BlaExampleObject getFromStorageById(long id)  {
    return (BlaExampleObject)super.getFromStorageById(id);
  public BlaExampleObject getFromStorageByName(String name)  {
    // whatever is necessary to get it from storage by name ...
    return this;
}The example how to use the cache:
public class BlaCacheExample {
  public BlaCacheExample()  {
    BlaObjectCache<BlaExampleObject> cache = new BlaObjectCache<BlaExampleObject>();
    // create first index by object-id
    int idHandle = cache.addIndex(new BlaObjectCacheIndex<BlaExampleObject,Long>() {
      public BlaExampleObject select(Long id) {
        return new BlaExampleObject().getFromStorageById(id);
      public Long extract(BlaExampleObject object) {
        return object.getId();
    // create second index by name
    int nameHandle = cache.addIndex(new BlaObjectCacheIndex<BlaExampleObject,String>() {
      public BlaExampleObject select(String name) {
        return new BlaExampleObject().getFromStorageByName(name);
      public String extract(BlaExampleObject object) {
        return object.getName();
    // get an object by id via cache
    BlaExampleObject object = cache.select(idHandle, new Long(1234));
    // get it via name
    object = cache.select(nameHandle, "test");
}The cache:
import java.util.*;
* Object cache with multiple unique indexes.
public class BlaObjectCache<T extends BlaObject> {
  // >>>>> WHAT IS THE CORRECT DECLARATION FOR '?'  <<<<< ??????????????????
  private List<BlaObjectCacheIndex<T,?>> indexes;   // the indexes
   * creates an instance of an BlaObjectCache.
  public BlaObjectCache() {
    indexes = new ArrayList<BlaObjectCacheIndex<T,?>>();
   * add a unique index
   * @param index is the index to add
   * @return the handle to the index
  public <C extends Comparable<? super C>> int addIndex(BlaObjectCacheIndex<T,C> index)  {
    indexes.add(index);
    return indexes.size() - 1;
   * Retrieve object via cache
   * @param handle is the index-handle
   * @param key is unique key
   * @return the object or null if no such object
  public <C extends Comparable<? super C>> T select(int handle, C key)  {
      BlaObjectCacheIndex<T,C> index = (BlaObjectCacheIndex<T,C>)indexes.get(handle);
      T obj = index.get(key);   // get object from cache
      if (obj == null)  {
        // not in cache: get it from storage
        obj = index.select(key);
        if (obj != null)  {
          // add object to all indexes
          for (BlaObjectCacheIndex<T,?> ndx: indexes)  {
            ndx.add(obj);
      return obj;
}and the cache index:
import java.util.*;
* Generic Cache index.
public abstract class BlaObjectCacheIndex<T extends BlaObject, C extends Comparable<? super C>> {
  private TreeMap<C, T> cacheMap;     // mapping of keys to BlaObjects
   * Create a new index.
  public BlaObjectCacheIndex()  {
    cacheMap = new TreeMap<C, T>();
   * Select a BlaObject by a unique key from storage.
   * @param key uniquely identifies the object
   * @return the selected object or null if it does not exist.
  abstract public T select(C key);
   * Extract the key object.
   * @param object is the object to extract the key from
   * @return the key
  abstract public C extract(T object);
   * get object from cache by key.
   * @param key is the Comparable that uniquely identifies the object
   * @return the object or null if not in cache
  public T get(C key)  {
    return cacheMap.get(key);
   * add an object to the index.
   * @param object is the object to append
   * @return true if added, false if object already in index
  public boolean add(T object) {
    return cacheMap.put(extract(object), object) == null;  
}The BlaObjectCacheIndex is 100% generic and typesafe.
The problem arises in BlaObjectCache because it contains a
List of BlaObjectCacheIndexes with different <C extends Comparable<? super C>>.
Hence, I cannot make C a generic type variable
for BlaObjectCache. However, I can force type checking for 'C' in
the method-declarations of BlaObjectCache.
Unfortunately, there is no way to describe
that this List contains such elements. At least, I couldn't figure out
how, so far :-(
My reasoning is: there is no nasty type-casting or whatever trick in BlaObjectCacheIndex.
The type-constraints correspond to the real demands of the application.
A generic type like <C extends Comparable<? super C>> is not rocket science ;-)
I just want to learn how to get the List-declaration right.
Can you explain how?
Regards,
Harald