Question

I want to implement the following function:

public boolean checkType(Vector<?> vec)
{
  // return true if its Vector<Integer> and false otherwise
}

How can I check the vector elements type ?
Note that the vector might be empty thus I can’t check if the first element is “instanceof” Integer or String …

EDIT:

Well, I had something in mind I don’t know if it will work or not

Can I implement the checkType function as following:

public <T> boolean checkType(Vector<T> vec)
{
  // return true if T is Integer and false otherwise
}

is it possible to check if T is Integer ?!

Thanks in Advance

Answer 1

Generic type parameters are unrecoverable (except for some special cases) at runtime because of type erasure. This means that at runtime, both Vector<Integer> and Vector<String> are simply just Vectors and their elements are just Object references.

Only the actual runtime classes (discoverable by instanceof checks as you pointed out) of the individual elements make the notion of the element type, otherwise the Vector itself has no idea what it’s element type is.

So basically, an empty vector of any type is equal to empty vector of any other type. It is even safe to cast it like this:

Vector<String> noStrings = (Vector<String>) new Vector<Integers>();

However there is one problem, because although you can say that empty vector conforms to any required element type, this statement stands only as long as the vector stays empty. Because if you do this:

Vector<Integer> ints = new Vector<Integer>(); // empty
Vector<String> strings = (Vector<String>) ints; // unchecked warning, but still possibly ok
ints.add(1); // here comes trouble
String s = strings.get(1); // oh oh, ClassCastException

EDIT:

To answer you second question: No it isn’t possible to write anything like this:

public <T> boolean checkType(Vector<T> vec) {
    return T instanceof Integer; // impossible
    return T == Integer; // impossible
    return T.class == Integer.class // impossible
    return vec instanceof (Vector<Integer>); // impossible
}

However you can write a method that uses a class token as an input parameter:

static <T> boolean checkElementType(Collection<?> collection, Class<T> elementType) {
    for (Object object : collection) {
        if (!elementType.isAssignableFrom(object.getClass())) {
            return false;
        }
    }
    return true;
}

And then you can use it like this:

List<?> list1 = Arrays.asList(1, 2, 3);
List<?> list2 = Arrays.asList(1, 2, 3, "a");
System.out.println(checkElementType(list1, Integer.class)); // true
System.out.println(checkElementType(list2, Integer.class)); // false