主页 / 问题 / 1592958
Accepted
AP-JavaCod
Asked:2024-09-06 00:42:08 +0000 UTC2024-09-06 00:42:08 +0000 UTC

如何使用泛型方法将 List<T> 转换为 T[] 数组

  • 772

我的代码：

public static <T> T[] getArray(List<T> list){
    return (T[]) list.toArray(); 
}

当调用该方法时，会抛出异常：

List<Integer> list = Arrays.asList(1, 2, 3, 4);
Integer[] arr = getArray(list); //Возникает исключение ClassCastException

是否可以从 转换List<T>为T[]？

此处不可能创建循环，因为不可能创建泛型数组，例如：T[] array = new T[5]; 因为代码未编译。

java

2 个回答

  1. Best Answer

    问题中提出的方法实现使用始终返回对象数组的方法getArray，因此为该数组转换类型是没有意义的，并且总是会抛出异常：List::toArrayObject[]

    List<Integer> list = Arrays.asList(1, 2, 3, 4);
Integer[] arr = (Integer[]) getArray(list);  // java.lang.ClassCastException: class [Ljava.lang.Object; cannot be cast to class [Ljava.lang.Integer;...

    因此，您需要使用一种返回正确类型数组的方法List::toArray(T[] arr)，您应该向其中传递一个已知类型的数组，并且建议该数组的大小为零（请参阅Alexey Shipilev (2016) 的帖子）。

    T然而，这提出了在泛型方法中创建所需类型的数组getArray以便将其传递给该方法的问题List::toArray(T[] arr)（请参阅泛型和数组（2013））。
    要创建数组，您应该使用 方法，该方法需要有关数组元素所属类的java.lang.reflect.Array.newInstance(Class<?> componentType, int size)信息作为输入参数。

    最简单的方法是将类的信息作为参数传递给原始方法：

    @SuppressWarnings("unchecked")
public static <T> T[] getArray(List<? super T> list, Class<? super T> clazz) {
    return list.toArray((T[]) Array.newInstance(clazz, 0));
}

// использование
List<Integer> list = Arrays.asList(1, 2, 3, 4);
Integer[] arr = getArray(list, Integer.class);  // всё работает

    此实现允许您为数组元素设置所需的类，该类也可以是数组元素的父（祖先）类：

    List<Integer> list = Arrays.asList(1, 2, 3, 4);
Number[] arrNum = getArray(list, Number.class);  // всё работает
arrNum[0] = 1.5;
arrNum[1] = 0.5f;

Object[] objs = getArray(List.of(""), Object.class); 
objs[0] = new Object();

List<Double> listDouble = Arrays.asList();
Double[] doubles = getArray(listDouble, Double.class); // пустой массив Double

    此方法也适用于空列表或当结果数组的类型是列表中元素的父类 ( List<Child>-> ) 时，因为通过附加参数显式Parent[]提供有关元素类型的信息更容易的方法。Class<T>getArray

    假设有一个层次结构：

    class Parent {
    @Override
    public String toString() {
        return this.getClass().toString();
    }
}

class Child extends Parent {}
class Grand extends Child {}

    那么包含不同元素的列表：var foo = List.of(new Child(), new Grand(), new Parent());只能通过显式指定结果数组的类型来转换为“父母”数组：

    var allTypes = List.of(new Child(), new Grand(), new Parent());
Parent[] foo = getArray(allTypes, Parent.class); // наиболее общий тип для успешной конвертации

var children = List.of(new Child(), new Grand(), new Grand());
Parent[] bar = getArray(children, Parent.class); // тип для успешной записи "родителя"
bar[0] = new Parent();

    但是，如果输入列表非空且同构（至少包含一个同类非空元素），并且需要将其转换为同类元素数组，即List<T>-> T[]，则从第一个匹配元素中提取类信息就足够了：

    private static <T> Class<?> findItemClass(List<T> list) {
    return list.stream()
               .filter(Objects::nonNull)
               .findFirst()
               .map(Object::getClass)
               .orElse(Object.class);
}

@SuppressWarnings("unchecked")
public static <T> T[] sameTypeArray(List<T> list) {
    Class<?> clazz = findItemClass(list);
    return list.toArray((T[]) Array.newInstance(clazz, 0));
}

// использование
List<Integer> list = Arrays.asList(null, 1, 2, 3, 4, null);
Integer[] arr = sameTypeArray(list);  // всё работает

    当然，这种方法的结果可以分配给父类型的数组，因为数组是协变的，但是如果您尝试向该数组写入不正确的值，则会抛出异常ArrayStoreException：

    Number[] arrInt = sameTypeArray(list);  // ок, тип массива [Ljava.lang.Integer
arrInt[0] = 1.5; // ArrayStoreException, попытка записи Double в Integer[]

Object[] arrObj = sameTypeArray(List.of("")); // [Ljava.lang.String
arrObj[0] = new Object(); // ArrayStoreException, попытка записи Object в String[]

    如有必要，可以增强该方法findItemClass以查找非空列表元素的最常见父类，如下所示：

    static Class<?> commonSuperclass(Class<?> a, Class<?> b) {
    while (!a.isAssignableFrom(b))
        a = a.getSuperclass();
    return a;
}

static <T> Class<?> findItemClass(List<? extends T> list) {
    return list.stream()
        .filter(Objects::nonNull)
        .map(Object::getClass)
        .reduce(MyClass::commonSuperclass) // ссылка на метод выше
        .orElse(Object.class);
}

    通过此实现，可以针对不同元素转换列表：

    var family = Arrays.asList(null, new Child(), new Grand(), new Parent());
var arrFamily = getArray(family); // [LParent

var kids = Arrays.asList(null, new Child(), new Grand(), null);
var arrKids = getArray(kids); // [LChild
    • 1

  2. 一个有效但丑陋的解决方案。

    abstract class ArrayFactory<T> {
    private final List<T> list;

    public ArrayFactory(List<T> list) {
        this.list = list;
    }

    @SneakyThrows
    public T[] toArray() {
        Type arg = ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];
        Class<?> clazz = getClass().getClassLoader().loadClass(arg.getTypeName());
        return list.toArray((T[]) Array.newInstance(clazz, list.size()));
    }
}

    像这样使用：

        Parent[] array = new ArrayFactory<>(List.of(new Child(), new Parent())) {}.toArray();

    另一种选择是切换到 Scala。

    • 1

相关问题