Effective Java - 第25项 - 泛型类转换异常混合列表和数组

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 Object s, 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.