Java language - dynamic instanceof

The instanceof keyword is well known and well understood. It certainly isn't the most OO part of Java, but it is one that the vast majority of programs will use somewhere. Is it possible that even this familiar operator could be improved?

instanceof

Lets consider a method that finds all the Strings in a mixed collection which might contain any kind of object:

  public Collection<String> extract(Collection<?> coll) {
    Collection<String> result = new ArrayList<String>();
    for (Object obj : coll) {
      if (obj instanceof String) {
        result.add((String) obj);
      }
    }
    return result;
  }

Nothing strange here. But what if we want to pass in the type to check for at runtime?

  public <T> Collection<T> extract(Collection<?> coll, Class<T> type) {
    Collection<T> result = new ArrayList<T>();
    for (Object obj : coll) {
      if (type.isInstance(obj)) {
        result.add((T) obj);
      }
    }
    return result;
  }

Suddenly, we can't use the instanceof operator. Instead we have to use the isInstance() method on the type itself. What would be neat would be a more dynamic instanceof operator:

  public <T> Collection<T> extract(Collection<?> coll, Class<T> type) {
    Collection<T> result = new ArrayList<T>();
    for (Object obj : coll) {
      if (object instanecof type) {
        result.add((T) obj);
      }
    }
    return result;
  }

This code sample is using instanceof to check the type of a Class object, rather than a hard coded compile-time Class literal. Of course, its really just syntax sugar for type.isInstance(obj), possibly with null-handling.

This strikes me as something that probably should have been in Java from the start, and has minimal potential for damage if added now. However, its also a pretty specialised operation, rarely used and has a simple enough workaround.

Thus, I fear this is one for the 'nice idea, but not worth the effort' pile. Any opinions?