2

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

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

3 回答 3

3

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

于 2013-02-13T17:21:03.553 回答
0

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

于 2013-02-13T17:20:41.100 回答
0

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

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

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

于 2013-02-13T18:40:51.133 回答