Java从另一个数组的通用运行时类型创建数组

Question

我有以下代码，它合并了两个数组，应该处理除原语之外的任何类型。

@SuppressWarnings("unchecked")
public static synchronized <E> E[]  aryMergeNoDup(E[]... arys){
    HashSet<E> hs = new HashSet<E>();
        for(E[] ary : arys) {
            if(ary == null) continue;
            for(E item : ary) {
                if(item != null) hs.add(item);
            }
        }
        hs.remove(null);
        return hs.toArray((E[]) Array.newInstance(
                arys.getClass().getComponentType(),hs.size()));
}

但是当代码运行时，它会产生这个异常：

java.lang.ArrayStoreException: java.lang.String
  at java.util.AbstractCollection.toArray(AbstractCollection.java:188)
  at util.Utils.aryMergeNoDup(Utils.java:197)

变量arys的运行时类型为String[]；但是，当我将 arys.getClass().getComponentType() 替换为 String.class 时，代码运行良好。

但是，该方法只能用于字符串，因为 pf this.我看不出出了什么问题，因为他们都应该引用java.lang.String。

AbstractCollection.java:188 中抛出异常的行是：

r[i] = (T)it.next();

public <T> T[] toArray(T[] a) {
    // Estimate size of array; be prepared to see more or fewer elements
    int size = size();
    T[] r = a.length >= size ? a :
              (T[])java.lang.reflect.Array
              .newInstance(a.getClass().getComponentType(), size);
    Iterator<E> it = iterator();

    for (int i = 0; i < r.length; i++) {
        if (! it.hasNext()) { // fewer elements than expected
            if (a != r)
                return Arrays.copyOf(r, i);
            r[i] = null; // null-terminate
            return r;
        }
        r[i] = (T)it.next();
    }
    return it.hasNext() ? finishToArray(r, it) : r;
}

Answer 1

由于它是可变参数，arys 的运行时类型将是 E[][]，而不是 E[]。因此，您可能需要arys.getClass().getComponentType().getComponentType() 作为Array.newInstance 的参数。

Answer 2

我认为问题在于arys 类似于数组数组。所以arys.getClass().getComponentType() 可能是String[]，而不是String。

Answer 3

你有两个不同的东西在这里交互。首先，您使用的是可变参数，它在幕后将它们的参数包装在一个动态生成的数组中。所以 arys 的类型将是 E[][]，所以获取组件类型将是 E[]。其次，泛型意味着 E 在运行时被擦除为 Object，因此即使两次 getComponentType 调用也不会删除它 - 除非您可以始终返回 Object[]。

您可以做的是使用 arys[0] 的组件类型（如果存在）。这甚至不适用于所有情况，因为例如第二个数组的类型可能是超类或第一个的兄弟，赋值与第一个类型的数组不兼容。

要解决这个问题，您可以通过检查所有数组的类型来计算最小上限类型，但如果您的典型用法是相同类型的数组，我认为这与“第一种类型获胜”相比是多余的。