Effective Java - Item 25 - Generics class cast exception Mixing List and Arrays

Question

I'm reading Effective Java 2nd edition from Joshua Bloch, item 25 (page 122). As you read further into the chapter, you get to a point where the author writes the following code :

// Naive generic version of reduction - won't compile!
static <E> E reduce(List<E> list, Function<E> f, E initVal) {
    E[] snapshot = list.toArray(); // Locks list
    E result = initVal;
    for (E e : snapshot)
    {
        result = f.apply(result, e);
    }
    return result;
}

Then the author states that the compiler won´t compile this because you need to add an explicit cast to the line where is the assignment E[] snapshot = list.toArray();, resulting on this E[] snapshot = (E[]) list.toArray();, and after this you well get a warning saying that there is [unchecked] unchecked cast.

---

Q1: I know that the book was taking into account changes up to Java 6 (and we are at Java almost 8 right now). However, I wrote the same method, a get the same error from the compile. This is because I am required to add the explicit cast. There is however no warning. So what is that warning about?

---

Q2: The author states the following method will work but it turns out that it isn't type safe.

With minor modifications, you could get it to throw a ClassCastException on a line that doesn't contain an explicit cast.

Okay, I understand that... but how can I get it to throw a ClassCastException?

---

I leave this post with a ready to run example, if you want to check the things for yourselves:

import java.util.Arrays;
import java.util.List;

public class Main
{

    public static void main(String[] args)
    {
        List<Integer> ints = Arrays.asList(10,20,30);
        Integer result = reduce (ints,new Function<Integer>() {

            @Override
            public Integer apply(Integer arg1, Integer arg2)
            {
                return arg1 + arg2;
            }
        },0);
        System.out.println(result);
    }

    static <E> E reduce(List<E> list, Function<E> f, E initVal)
    {
        E[] snapshot = (E[]) list.toArray(); // Locks list
        E result = initVal;
        for (E e : snapshot)
        {
            result = f.apply(result, e);
        }
        return result;
    }

    interface Function<T>
    {
        public T apply(T arg1, T arg2);
    }
}

Answer 1

E[] snapshot = list.toArray();

list.toArray() returns Object[] instead of E[]. So you need an explicit cast there. But the presence of the explicit (or dynamic) cast like that means that compiler could not guarantee the type-safety there. Instead your are telling the compiler that everything is fine and it will actually be an E[] at runtime. So, it gives you a warning about it saying - unchecked cast. Note, that if the compiler was able to guarantee the type-safety there, then it would be a static/checked cast (performed implicitly by the compiler itself) there, instead.

Answer 2

Question one: Why is E[] snapshot = (E[]) list.toArray(); warning about unsafe check?

The reason is that, in java, arrays keep their type information, while generics get erased. At runtime all List<String>, List<Dog> and List<NuclearBomb> are effectively List<Object>.

Therefore:

List<E> list becomes List<Object>

And

E[] array = (E[]) list.toArray();

Is unsafe.

Question two: How can that fail at runtime?

If java lets you do

E[] array = (E[]) list.toArray();

with a list of Objects, it will also let you do:

String[] array = (String[]) list.toArray();

Since strings are objects after all. That line would compile (with a warning) and on runtime you'd get a cast exception.

Answer 3

I think the compiler when it sees an explicit cast raises a warning where generics and arrays are combined . if you remember the earlier example in Bloch effective java page 117

return (T[]) Arrays.copyOf(elements, size, a.getClass());

In the above scenario also the compiler generates a warning : [unchecked] unchecked cast. Although we are pretty much sure at the runtime that array returned will always be of type T. But it is suppressed by using @SuppressWarnings annotation.

Answer 4

For Question2, I try to understand the author by codes below.

caller:

List<String> list = Arrays.asList("string");
reduce(list, new Function<String>() {
    @Override
    public String apply(String arg1, String arg2) {
        return "";
    }
}, "");

the "reduce" mothod:

static <E> E reduce(List<E> list, Function<E> f, E initVal) {
    // /*
    List<E> snapshot;
    synchronized (list) {
        snapshot = new ArrayList<>(list);
    }
    snapshot.set(0, 123);    // compile error here
    // */

    /*Object[] objs = list.toArray();
    objs[0] = 123;  // will cause ClassCastException on runtime
    E[] snapshot = (E[]) objs;*/
    E result = initVal;
    for (E e : snapshot) {
        result = f.apply(result, e);
    }
    return result;
}

Maybe it's not such "With minor modifications", but it is an appropriate expaination.