Java 将列表转换为双[][]

使用下面的代码，我正在尝试将一个双倍列表转换为Double[]。但是在方法上：

Double[]dim=list1.toArray（新的Double[2][2]）我收到此错误：

Exception in thread "main" java.lang.ArrayStoreException
    at java.lang.System.arraycopy(Native Method)
    at java.util.ArrayList.toArray(ArrayList.java:361)
    at clustering.main.ConvertArrayTest.main(ConvertArrayTest.java:22)

错误发生在这一行：

Double[][] dim = list1.toArray(new Double[2][2]); 

我如何才能正确转换列表

守则：

import java.util.ArrayList;
import java.util.List;

public class ConvertArrayTest {

    public static void main(String args[]){

        List<ArrayList<Double>> list1 = new ArrayList<ArrayList<Double>>();
        ArrayList<Double> list2 = new ArrayList<Double>();

        list2.add(1.0);
        list2.add(1.0);
        list1.add(list2);

        list2 = new ArrayList<Double>();
        list2.add(2.0);
        list2.add(2.0);
        list1.add(list2);

        Double[][] dim = list1.toArray(new Double[2][2]);

    }

}

import java.util.ArrayList；
导入java.util.List；
公共类ConvertaryTest{
公共静态void main（字符串参数[]）{
List list1=新的ArrayList（）；
ArrayList list2=新的ArrayList（）；
清单2.添加（1.0）；
清单2.添加（1.0）；
列表1.添加（列表2）；
list2=新的ArrayList（）；
清单2.add（2.0）；
清单2.add（2.0）；
列表1.添加（列表2）；
Double[]dim=list1.toArray（新的Double[2][2]）；
}
}
因为
list1
是一个列表列表，当您调用
toArray
时，您将得到一个列表数组。您需要遍历它，分别转换每个内部列表。
使用以下方法：

代码：

public static void main(String[] args) {
    List<Double[]> list = new ArrayList<Double[]>();
    list.add(new Double[] { 1.0 });
    list.add(new Double[] { 2.0, 2.0 });
    list.add(new Double[] { 3.0, 3.0, 3.0 });
    Double[][] array = list.toArray(new Double[list.size()][]);
    for (Double[] numbers : array) {
        System.out.println(Arrays.toString(numbers));
    }
}

[1.0]
[2.0, 2.0]
[3.0, 3.0, 3.0]

给你，固定的主要方法：

public static void main(String args[]){

        List<ArrayList<Double>> list1 = new ArrayList<ArrayList<Double>>();
        ArrayList<Double> list2 = new ArrayList<Double>();

        list2.add(1.0);
        list2.add(1.0);
        list1.add(list2);

        list2 = new ArrayList<Double>();
        list2.add(2.0);
        list2.add(2.0);
        list1.add(list2);

        Double[][] dim = new Double[2][2];
        int i = 0;
        for(ArrayList<Double> inner : list1)
            dim[i++] = inner.toArray(new Double[0]);
    }

publicstaticvoidmain（字符串参数[]）{
List list1=新的ArrayList（）；
ArrayList list2=新的ArrayList（）；
清单2.添加（1.0）；
清单2.添加（1.0）；
列表1.添加（列表2）；
list2=新的ArrayList（）；
清单2.add（2.0）；
清单2.add（2.0）；
列表1.添加（列表2）；
双精度[]尺寸=新双精度[2][2]；
int i=0；
用于（ArrayList内部：列表1）
dim[i++]=内部.toArray（新的双精度[0]）；
}

您的第一个列表是数组列表列表，因此您需要对其进行迭代。
我可能会创建这样一个方法-

public static Double[][] toDoubleArrayArray(
    List<ArrayList<Double>> al) {
  if (al == null) { // return null on null.
    return null;
  }
  Double[][] ret = new Double[al.size()][]; // declare the return array array.
  for (int i = 0; i < al.size(); i++) {
    ArrayList<Double> list = al.get(i); // get the inner list.
    if (list == null) { // handle null.
      ret[i] = null;
    } else {
      Double[] inner = new Double[list.size()]; // make the inner list an array.
      ret[i] = list.toArray(inner); // store that array.
    }
  }
  return ret; // return
}

我认为只有当你的列表是一个数组列表时，这才有效。OP有
双倍数组列表
而不是
双倍数组列表
哦，对不起。但下一次，为了避免让别人对错误发表明显的评论，最好暂时删除答案，纠正错误，然后再删除。
public static void main(String[] args) {
  List<ArrayList<Double>> list1 = new ArrayList<ArrayList<Double>>();
  list1.add(new ArrayList<Double>(Arrays.asList(1.0, 1.0)));
  list1.add(new ArrayList<Double>(Arrays.asList(2.0, 2.0)));

  Double[][] arr = toDoubleArrayArray(list1);
  for (int i = 0; i < arr.length; i++) {
    System.out.println(Arrays.toString(arr[i]));
  }
}

[1.0, 1.0]
[2.0, 2.0]