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

Question

我正在阅读Joshua Bloch撰写的Effective Java第2版，第25项（第122页）。 当您进一步阅读本章时，您会发现作者编写以下代码：

// 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;
}

然后作者声明编译器不会编译它，因为你需要在赋值E[] snapshot = list.toArray();的行中添加一个显式的E[] snapshot = list.toArray(); ，导致这个E[] snapshot = (E[]) list.toArray(); ，在此之后你会得到一个警告，说有[unchecked] unchecked cast 。

---

问题1：我知道这本书考虑到了Java 6的变化（我们现在的Java几乎是8）。 但是，我写了相同的方法，从编译中得到相同的错误。 这是因为我需要添加显式强制转换。 但是没有警告。 那个警告是什么？

---

Q2：作者声明以下方法可行但事实证明它不是类型安全的 。

通过微小的修改，您可以让它在不包含显式ClassCastException的行上抛出ClassCastException 。

好的，我理解......但是如何让它抛出ClassCastException呢？

---

如果你想为自己检查一下，我将这篇文章留下准备好运行的例子：

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()返回Object[]而不是E[] 。 所以你需要一个明确的演员。 但是这样的显式（或动态）转换的存在意味着编译器无法保证那里的类型安全性。 相反，你告诉编译器一切都很好，它在运行时实际上是一个E[] 。 因此，它会给你一个关于它的警告 - 未经检查的演员 。 注意，如果编译器能够保证那里的类型安全性，那么它将是静态/检查的强制转换（由编译器本身隐式执行）。

Answer 2

问题一：为什么E[] snapshot = (E[]) list.toArray(); 关于不安全检查的警告？

原因是，在java中，数组保留其类型信息，而泛型则被删除。 在运行时，所有List<String> ， List<Dog>和List<NuclearBomb>都是有效的List<Object> 。

因此：

List<E> list变为List<Object>

和

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

不安全。

问题二：如何在运行时失败？

如果java允许你这样做

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

使用Object列表，它还可以让您：

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

因为字符串毕竟是对象。 该行将编译（带有警告），在运行时，您将获得强制转换异常。

Answer 3

我认为编译器在看到显式转换时会引发一个警告，其中泛型和数组被组合在一起。 如果你还记得Bloch有效的java第117页中的早期例子

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

在上面的场景中，编译器也会生成一个警告：[unchecked] unchecked cast。 虽然我们在运行时非常确定返回的数组将始终为T类型但是它通过使用@SuppressWarnings注释来抑制。

Answer 4

对于Question2，我尝试通过以下代码了解作者。

呼叫者：

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

“减少”方法：

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;
}

也许它不是“经过微小修改”，但它是一个适当的表达。