Type safety: Unchecked cast from Object to List

Question

I have a ListView listing a custom object (let's say MyObject).

I want to filter it dynamically through an EditText so I had to implement a getFilter() with a publishResults method:

@Override
protected void publishResults(CharSequence constraint, FilterResults results) {
    MyObjectAdapter.this.setItems((List<MyObject>) results.values);
    MyObjectAdapter.this.notifyDataSetChanged();
}

At this point, Eclipse complains: Type safety: Unchecked cast from Object to List<MyObject>

I am sure this cast will always be true, but Eclipse only suggests to add @SuppressWarnings("unchecked") but I'm totally against SuppressWarnings because it's only hiding the problem, not a solution...

I tried adding:

if(results.values instanceof List<MyObject>)

But Eclipse complains again, and this solves nothing...

Cannot perform instanceof check against parameterized type List<MyObject>. Use the form List<?>

I know the casting will always be correct, but which is the proper way to make the code to be sure results.values is actually a List<MyObject> ?

Thanks in advance!

http://stackoverflow.com/questions/262367/type-safety-unchecked-cast — Elrond_EGLDer, Dec 28 '15 at 09:04

score 23 · Answer 1 · answered Feb 01 '13 at 09:38

If all you have to work from is an Object, then you can't check at runtime that you actually have a List<MyObject>, because the generic type MyObject is only used for compile-time type checking, it is not available at runtime. This is why you get an error when you try to add the instanceof check.

If you are sure that your Object really is always a List<MyObject> then I'd say the @SuppressWarnings is OK, if you document why you are sure it is not a problem.

If you absolutely want to avoid a warning though, you could create your own List implementation (say, MyObjectList) that is not itself generic but implements List<MyObject>. Then you can do an instanceof check against MyObjectList at runtime.

Another option is to check for and cast to List<?> as the instanceof error suggests. Then you can iterate over the elements in the list and check if they are actually all instances of MyObject, and copy them to a new List<MyObject>.

score 16 · Accepted Answer · answered Feb 01 '13 at 11:45

Well, I finally managed to find a solution.

Just as @Medo42 said:

Another option is to check for and cast to List as the instanceof error suggests. Then you can iterate over the elements in the list and check if they are actually all instances of MyObject, and copy them to a new List.

Even though I did not went through the process of creating a whole new object in order to make this particular case to work "warning-less" this was the right direction to go.

So I took @lokoko 's idea and use it in a new setItems() method, with an Object parameter instead of a List<MyObject> in order to make sure

The result code is the following:

public void setItems(List<MyObject> var){
    this.list = var;
}

public void setItems(Object var){
    List<MyObject> result = new ArrayList<MyObject>();
    if (var instanceof List){
        for(int i = 0; i < ((List<?>)var).size(); i++){
            Object item = ((List<?>) var).get(i);
            if(item instanceof MyObject){
                result.add((MyObject) item);
            }
        }
    }
    setItems(result);
}

Thanks everyone for your help!

score 15 · Answer 3 · edited May 23 '15 at 17:09

15

Try something like this :

List<?> result = (List<?>) results.values;
for (Object object : result) {
    if (object instanceof MyObject) {
        tempList.add((MyObject) object); // <-- add to temp
    }
}

filteredItems = tempList; // <-- set filtered

edited May 23 '15 at 17:09

Jared Burrows

50,718
22
143
180

answered Feb 01 '13 at 10:34

lokoko

5,639
3
32
66

Your solution helped me to figure out how to solve my problem, thx! – Eloi Navarro Feb 01 '13 at 11:50

Lawrence Choy · Answer 4 · 2013-02-01T09:42:14.793

3

You can perform the checking before passing it to setItems().

final Object myListObj = reuslts.values;
if(myListObj instanceof List<?>) {
    if(((List<?>)myListObj).get(0) instanceof MyObject)
        // You can safely suppress the warning here because you made sure it is a List containing MyObject
        MyObjectAdapter.this.setItems((List<? extends MyObject>) myListObj);

}

However, you need to change your setItems() method accordingly:

public void setItems(List<? extends MyObject> list) {
    // Your code here
}

edited Feb 01 '13 at 09:42

answered Feb 01 '13 at 09:37

Lawrence Choy

5,768
1
18
28

This check only ensures that the *first* object in the list is a `MyObject`, so the only thing you have shown is that the list *can* contain such elements - not that it actually is a `List` or even a `List extends MyObject>`. Rather, you have shown that it is a `List super MyObject>`. – Medo42 Feb 01 '13 at 09:45
You are correct. However, a `List` can never contains an element of `Integer` right? If `MyObject` has no subclass this works well. Even if the objects inside `extends MyObject`, they all contains necessary interface or functions that `MyObjectAdapter` required, because method signature decladed `MyObject`, not other subclasses. – Lawrence Choy Feb 01 '13 at 09:50
Technically, a `List` *can* contain an `Integer` because the generic type of the list is not enforced at runtime. But even if you had that guarantee and even if `MyObject` has no subclasses your suggestion isn't valid. Imagine a `List – Medo42 Feb 01 '13 at 10:14

Type safety: Unchecked cast from Object to List

4 Answers4

Linked