What is unchecked cast and how do I check it?

Question

Hi, I think I get what unchecked cast means (casting from one to another of a different type), but what does it mean to "Check" the cast? How can I check the cast so that I can avoid this warning in Eclipse? Thanks,

Answer 1

Unchecked cast means that you are (implicitly or explicitly) casting from a generic type to a nonqualified type or the other way around. E.g. this line

Set<String> set = new HashSet();

will produce such a warning.

Usually there is a good reason for such warnings, so you should try to improve your code instead of suppressing the warning. Quote from Effective Java, 2nd Edition:

Eliminate every unchecked warning that you can. If you eliminate all warnings, you are assured that your code is typesafe, which is a very good thing. It means that you won’t get a ClassCastException at runtime, and it increases your confidence that your program is behaving as you intended.

If you can’t eliminate a warning, and you can prove that the code that provoked the warning is typesafe, then (and only then) suppress the warning with an @SuppressWarnings("unchecked") annotation. If you suppress warnings without first proving that the code is typesafe, you are only giving yourself a false sense of security. The code may compile without emitting any warnings, but it can still throw a ClassCastException at runtime. If, however, you ignore unchecked warnings that you know to be safe (instead of suppressing them), you won’t notice when a new warning crops up that represents a real problem. The new warning will get lost amidst all the false alarms that you didn’t silence.

Of course, it is not always as easy to eliminate warnings as with the code above. Without seeing your code, there is no way to tell how to make it safe though.

Answer 2

If you hover your mouse over the warning in eclipse it usually gives you options on how to fix it.

I see this usually happen for casting maps or lists

Map stuff = (Map) object;

Should be

Map<?,?> stuff = (Map<?,?>) object;

The other option is above the method call the annotation:

@SuppressWarnings("unchecked")

Answer 3

To ellaborate more on what Peter wrote:

Casts from non-generic types to generic types may work just fine at runtime, because the generic parameters are erased during compilation, so we are left with a legitimate cast. However, The code may fail later with an unexpected ClassCastException due to a wrong assumption regarding the type parameter. For example:

List l1 = new ArrayList();
l1.add(33);
ArrayList<String> l2 = (ArrayList<String>) l1;
String s = l2.get(0);

The unchecked warning in line 3 indicates that the compiler is not able to guarantee type safety anymore, in the sense that an unexpected ClassCastException may occure somewere later. And this happens at line 4, which performs an implicit cast.