我已经搜索过了，但是不幸的是，我没有得到正确的答案。

class Helper {
    public static <T> T[] toArray(List<T> list) {
        T[] array = (T[]) new Object[list.size()];
        for (int i = 0; i < list.size(); i++) {
            array[i] = list.get(i);
        }
        return array;
    }
}

测试一下：

public static void main(String[] args) {
    List<String> list = new ArrayList<String>();
    list.add("abc");
    String[] array = toArray(list);
    System.out.println(array);
}

但是有一个错误抛出：

Exception in thread "main" java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [Ljava.lang.String;
at test.Helper.main(Helper.java:30)

如何解决呢？

更新

我需要此方法，因为有时代码中的类型太长：

newEntries.toArray(new IClasspathEntry[0])

我希望致电：

toArray(newEntries)

最后

创建这样的方法似乎是不可能的，非常感谢大家！

您可以调用list.toArray(T[] array)而不用担心自己实现它，但是正如aioobe所说，由于类型擦除，您不能创建通用类型的数组。如果需要返回该类型，则需要自己创建一个类型化实例并将其传递。

这是由于类型擦除。泛型会在编译时删除，因此Helper.toArray会被编译为返回Object[]。

对于这种特殊情况，建议您使用List.toArray(T[])。

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

如果要通过蛮力产生方法，并且可以保证只在有一定限制的情况下调用该方法，则可以使用反射：

public static <T> T[] toArray(List<T> list) {
    T[] toR = (T[]) java.lang.reflect.Array.newInstance(list.get(0)
                                           .getClass(), list.size());
    for (int i = 0; i < list.size(); i++) {
        toR[i] = list.get(i);
    }
    return toR;
}

这种方法有问题。由于list可以存储T的子类型，因此如果您的第一个元素是子类型，则将列表的第一个元素视为代表类型将产生强制转换异常。这意味着T不能是接口。另外，如果您的列表为空，则将获得索引超出范围的异常。

仅当您仅打算在列表的第一个元素与列表的通用类型匹配时调用该方法时，才应使用此方法。使用提供的toArray方法更加健壮，因为提供的参数告诉您要返回的数组类型。

您不能像在此处那样实例化泛型类型：

 T[] array = (T[]) new Object[list.size()];

因为，如果T绑定到类型，则要将新Object数组类型转换为绑定的类型T。我建议改用List.toArray(T[])方法。

见番石榴的Iterables.toArray(list, class)。

例：

@Test
public void arrayTest() {
    List<String> source = Arrays.asList("foo", "bar");
    String[] target = Iterables.toArray(source, String.class);
}

public static <T> T[] toArray(Collection<T> c, T[] a) {
    return c.size()>a.length ?
        c.toArray((T[])Array.newInstance(a.getClass().getComponentType(), c.size())) :
        c.toArray(a);
}

/** The collection CAN be empty */
public static <T> T[] toArray(Collection<T> c, Class klass) {
    return toArray(c, (T[])Array.newInstance(klass, c.size()));
}

/** The collection CANNOT be empty! */
public static <T> T[] toArray(Collection<T> c) {
    return toArray(c, c.iterator().next().getClass());
}

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

问题是不是String的数组的组件类型。

另外，最好不要提供空数组，例如new IClasspathEntry [0]。我认为最好给一个长度正确的数组（否则List＃toArray将创建一个新数组，这会浪费性能）。

由于类型擦除，一种解决方案是提供数组的组件类型。

例：

public static <C, T extends C> C[] toArray(Class<C> componentType, List<T> list) {
    @SuppressWarnings("unchecked")
    C[] array = (C[])Array.newInstance(componentType, list.size());
    return list.toArray(array);
}

在此实现中，类型C允许创建一个数组，该数组的组件类型是列表元素类型的超类型。

用法：

public static void main(String[] args) {
    List<String> list = new ArrayList<String>();
    list.add("abc");

    // String[] array = list.toArray(new String[list.size()]); // Usual version
    String[] array = toArray(String.class, list); // Short version
    System.out.println(array);

    CharSequence[] seqArray = toArray(CharSequence.class, list);
    System.out.println(seqArray);

    Integer[] seqArray = toArray(Integer.class, list); // DO NOT COMPILE, NICE !
}

等待泛型仿制药..

如前所述，这将起作用：

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

这也将起作用：

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

但是，在第一种情况下，将生成一个新数组。您可以看到这是如何在Android中实现的：

@Override public <T> T[] toArray(T[] contents) {
    int s = size;
    if (contents.length < s) {
        @SuppressWarnings("unchecked") T[] newArray
            = (T[]) Array.newInstance(contents.getClass().getComponentType(), s);
        contents = newArray;
    }
    System.arraycopy(this.array, 0, contents, 0, s);
    if (contents.length > s) {
        contents[s] = null;
    }
    return contents;
}

解决方案！

只需在项目中复制接口和类即可。这个 ：

public interface LayerDataTransformer<F, T> {
    T transform(F from);

    Collection<T> transform(Collection<F> from);

    T[] toArray(Collection<F> from);
}

和这个 ：

public abstract class BaseDataLayerTransformer<F, T> implements LayerDataTransformer<F, T> {

    @Override
    public List<T> transform(Collection<F> from) {
        List<T> transformed = new ArrayList<>(from.size());

        for (F fromObject : from) {
            transformed.add(transform(fromObject));
        }

        return transformed;
    }

    @Override
    public T[] toArray(Collection<F> from) {
        Class<T> clazz = (Class<T>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[1];
        T[] transformedArray = (T[]) java.lang.reflect.Array.newInstance(clazz, from.size());

        int index = 0;
        for (F fromObject : from) {
            transformedArray[index] = transform(fromObject);
            index++;
        }

        return transformedArray;
    }
}

用法。

声明BaseDataLayerTransformer的子类

public class FileToStringTransformer extends BaseDataLayerTransformer<File,String> {
    @Override
    public String transform(File file) {
        return file.getAbsolutePath();
    }
}

并使用：

FileToStringTransformer transformer = new FileToStringTransformer();
List<File> files = getFilesStub();// returns List<File>
//profit!
String[] filePathArray = transformer.toArray(files);

我使用这个简单的功能。IntelliJ只是讨厌类型为T []的类型，但效果很好。

public static <T> T[] fromCollection(Class<T> c, Collection<T> collection) {
    return collection.toArray((T[])java.lang.reflect.Array.newInstance(c, collection.size()));
}

呼叫看起来像这样：

Collection<Integer> col = new ArrayList(Arrays.asList(1,2,3,4));    
fromCollection(Integer.class, col);

我写的这个要点很好地解决了这个问题。

遵循siegi关于Atreys答案的建议，我编写了一个构造函数，该构造函数查找“最近的共同祖先”（NCA）类并使用该类创建数组。如果检查空值，并且提供的Collection的长度为0或所有空值，则默认类型为Object。它完全忽略了接口。

import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.ArrayList;
import java.lang.reflect.Array;
import java.util.Iterator;

public class FDatum<T> {

  public T[] coordinates;

  // magic number is initial size -- assume <= 5 different classes in coordinates
  public transient HashSet<Class> classes = new HashSet<Class>(5);

  public FDatum (Collection<T> coordinates) {

    // to convert a generic collection to a (sort of) generic array,
    //   we need to bend the rules:

    //   1. default class T is Object
    //   2. loop over elements in Collection, recording each unique class:
    //     a. if Collection has length 0, or
    //        if all elements are null, class T is Object
    //     b. otherwise, find most specific common superclass, which is T

    // record all unique classes in coordinates
    for (T t : coordinates)  this.classes.add(t.getClass());

    // convert to list so we can easily compare elements
    List<Class> classes = new ArrayList<Class>(this.classes);

    // nearest common ancestor class (Object by default)
    Class NCA = Object.class;

    // set NCA to class of first non-null object (if it exists)
    for (int ii = 0; ii < classes.size(); ++ii) {
      Class c = classes.get(ii);
      if (c == null) continue;
      NCA = c; break;
    }

    // if NCA is not Object, find more specific subclass of Object
    if (!NCA.equals(Object.class)) {
      for (int ii = 0; ii < classes.size(); ++ii) {
        Class c = classes.get(ii);
        if (c == null) continue;

        // print types of all elements for debugging
        System.out.println(c);

        // if NCA is not assignable from c,
        //   it means that c is not a subclass of NCA
        // if that is the case, we need to "bump up" NCA
        //   until it *is* a superclass of c

        while (!NCA.isAssignableFrom(c))
          NCA = NCA.getSuperclass();
      }
    }

    // nearest common ancestor class
    System.out.println("NCA: " + NCA);

    // create generic array with class == NCA
    T[] coords = (T[]) Array.newInstance(NCA, coordinates.size());

    // convert coordinates to an array so we can loop over them
    ArrayList<T> coordslist = new ArrayList<T>(coordinates);

    // assign, and we're done!
    for (int ii = 0; ii < coordslist.size(); ++ii)
      coords[ii] = coordslist.get(ii);

    // that's it!
    this.coordinates = coords;
  }

  public FDatum (T[] coordinates) {
    this.coordinates = coordinates;
  }

}

以下是在jshell中使用它的一些示例（为简洁起见，删除了“未经检查的”类警告）：

jshell> FDatum d = new FDatum(new ArrayList(Arrays.asList((double)1, (Double)3.3)))
class java.lang.Double
NCA: class java.lang.Double
d ==> com.nibrt.fractal.FDatum@9660f4e

jshell> d.coordinates
$12 ==> Double[2] { 1.0, 3.3 }

jshell> d = new FDatum(new ArrayList(Arrays.asList((double)1, (Double)3.3, (byte)7)))
class java.lang.Byte
class java.lang.Double
NCA: class java.lang.Number
d ==> com.nibrt.fractal.FDatum@6c49835d

jshell> d.coordinates
$14 ==> Number[3] { 1.0, 3.3, 7 }

jshell> d = new FDatum(new ArrayList(Arrays.asList((double)1, (Double)3.3, (byte)7, "foo")))
class java.lang.Byte
class java.lang.Double
class java.lang.String
NCA: class java.lang.Object
d ==> com.nibrt.fractal.FDatum@67205a84

jshell> d.coordinates
$16 ==> Object[4] { 1.0, 3.3, 7, "foo" }

当拥有泛型时，List<T>您将能够在运行时知道对象的类。因此，实现它的最佳方法是这样的：

public static <T> T[] list2Array(Class<T[]> clazz, List<T> elements)
{
    T[] array = clazz.cast(Array.newInstance(clazz.getComponentType(), elements.size()));
    return elements.toArray(array);
}

为什么需要该Class<T[]>参数？

因为，我们有一个通用列表，并且在保留类型安全性的同时，它不会提供必要的信息以获取我们要查找的精确类型的数组。与其他答案相反，这将使您返回一个Object数组，或者在编译时导致警告。这种方法将为您提供一个干净的解决方案。这里的“ hack”是clazz.cast()调用，无论您声明的实例类型如何，该调用都不会发出警告而进行编译list2Array()。

现在，您如何使用它？

很简单，只需这样称呼它：

List<String> list = Stream.of("one", "two", "three").collect(Collectors.toList());
String[] numbers = list2Array(String[].class, list);
System.out.println(Arrays.toString(numbers));

这是此的编译示例：https : //ideone.com/wcEPNI

为什么行得通？

之所以有效，是因为 可以使用编译器将类文字直接作为的实例java.lang.Class。这也适用于接口，枚举，任意维数组（例如String[].class），基元和关键字void。

Class 本身是通用的（声明为 Class<T[]>，其中T[]代表Class对象表示的类型），表示的类型String[].class为Class<String[]>。

注意：您将无法获得原语数组，因为原语不能用于类型变量。