Arrays or Vectors.

I don't see why it should be impossible.

public static <T> List<T> collect(
    Iterable<?> items, Class<? extends T> target
) {
    if (target.isPrimitive()) {
        throw new IllegalArgumentException();
    }
    List<T> found = new java.util.ArrayList<T>();
    for (Object item : items) {
        if (target.isInstance(item)) {
            found.add(item);
        }
    }
    return found;
}

@SuppressWarnings("unchecked")
public static <T> T[] collect(
    Iterable<?> items, Class<T> target
) {
    List<T> found = collect(items, target);
    return found.toArray((T[])
        java.lang.reflect.Arrays.newInstance(target, found.size())
    );
}

[Disclaimer: Not tested, or even compiled.]

I am not, however, convinced that this is a brilliant design.

Tom Hawtin

You want something like

   static <T> Vector<T> collect(Collection c, Class<T> clazz)
   {
       Vector<T> v = new Vector<T>();
       for (Object o : c)
       {
           if (clazz.isInstance(o))
               v.add((T) o);
       }
       return v;
  }

Class<T> is an idiom worth learning.  The only member (other than null) of
the type Class<T> is T.class.  If you're writing generic code and will need
access to the Class object for a parameterized type, having an argument of
type Class<T> is the way to get it.

Warning: I've compiled this but not tested it, so beware of subtle bugs.
Note also that isInstance() returns false for null arguments (like
instanceof does), so you'll never see null members in the Vector.

Probably not a good idea to design your API in terms of raw arrays, nor to use
Vector (essentially obsolete, and has been for many years).  But using
java.util.List it seems to work OK:

   -- chris

======== Utils.java ============
import java.util.*;

public class Utils
{
   public static <X>
   List<X>
   collect(List<Object> list, Class<X> clobj, boolean allowNull)
   {
       List<X> filtered = new ArrayList<X>();
       for (Object elem : list)
       {
           if (allowNull && elem == null)
               filtered.add(null);
           else if (clobj.isInstance(elem))
               filtered.add(clobj.cast(elem));
       }
       return filtered;
   }
}
======== Test.java ============
import java.util.*;

public class Test
{
   public static void
   main(String[] args)
   {
       List<Object> all = Arrays.asList(new Object[] {
                               "one",
                               null,
                               true,
                               false,
                               'c',
                               88.88,
                               100
                            });

       System.out.println("Strings (or null):");
       List<String> strings = Utils.collect(all, String.class, true);
       for (String s : strings)
           System.out.println("\t" + s);

       System.out.println("Numbers:");
       List<Number> numbers = Utils.collect(all, Number.class, false);
       for (Number n : numbers)
           System.out.println("\t" + n);
   }
}
=============================