Java 将ArrayList转换为包含不同长度数组的二维数组

因此，我：

ArrayList<ArrayList<String>> 

其中index是指包含字符串的数组索引

如何将其转换为二维数组，如下所示：

{{String1, String2, String3},{String4}, {}, {String5, String6}}

非常感谢。

您可以使用

toArray（）

方法将ArrayList转换为数组。由于在ArrayList中有ArrayList，因此需要迭代每个元素并应用此方法

大概是这样的：-

ArrayList<ArrayList<String>> mainList = new ArrayList<ArrayList<String>>();
// populate this list here
//more code

// convert to an array of ArrayLists
ArrayList<String[]> tempList = new ArrayList<String[]>();
for (ArrayList<String> stringList : mainList){
    tempList.add((String[])stringList.toArray());
}

//Convert to array of arrays - 2D array
String [][]list = (String[][])tempList.toArray();

ArrayList
String[][]数组=新字符串[ArrayList.size（）；
对于（int i=0；i

其中，
arrayList
是您的
arrayList
（或任何
列表
，相应地更改
循环的
内的第一行）
例如：

public String[][] toArray(List<List<String>> list) {
    String[][] r = new String[list.size()][];
    int i = 0;
    for (List<String> next : list) {
       r[i++] = next.toArray(new String[next.size()]);
    }
    return r;
}

public String[]toArray（列表）{
字符串[][]r=新字符串[list.size（）][]；
int i=0；
对于（列表下一步：列表）{
r[i++]=next.toArray（新字符串[next.size（）]）；
}
返回r；
}
欢迎来到Java 8的世界

我只花了一整晚没有睡觉就学会了写这一行奇怪的代码需要什么。我肯定它已经在某处了，但我找不到它。所以我分享我的研究时间，享受吧。呜

假设：

ArrayList<ArrayList<String>> mainList = new ArrayList<ArrayList<String>>();
// populate this list here

砰！一行

我不确定它与其他选项相比有多快。但这就是它的工作原理：

获取
mainList
2darraylist的流。这个流有点像一个向量，与一个LinkedList连接在一起，他们有了一个孩子。而那个孩子，晚年，服用了一些。我离题了
mainList.stream（）
正在返回
ArrayList
元素流。或者用更为古怪的说法：
mainList.stream（）
返回一个
流，就像一个简单的内联单行函数。它有两种数据类型。首先是调用它的流中的数据类型（
mainList.stream（）
）。下一种类型是它将映射到的数据类型，它位于lambda表达式的右半部分：
u->u.toArray（新字符串[0]）
。这里的
u
是您选择的标识符，就像使用
foreach
语句一样。前半部分是这样声明的：
u->
。与
foreach
一样，变量
u
现在将是流中的每个元素，因为它在流中迭代。因此，
u
属于原始流元素的数据类型，因为它就是原始流元素。Lambda表达式的右半部分显示如何处理每个元素：
u.toArray（新字符串[0]）
。将结果存储在新流中的正确位置。在本例中，我们将其转换为
字符串[]
。。因为毕竟，这是一个由
字符串
组成的二维数组。。或者更确切地说，从代码中的这一点来看，是一个由
String[]
（字符串数组）组成的一维数组。请记住，
u
最终是一个
ArrayList
。注意，从
ArrayList
对象调用
toArray
将创建一个传入该对象的类型的新数组。这里我们传入
新字符串[0]
。因此，它创建了一个新的数组，类型为
String[]
，长度等于ArrayList的长度
u
。然后它用
ArrayList
的内容填充这个新的字符串数组并返回它。这将保留Lambda表达式并返回到
映射中。然后，
map
收集这些字符串数组并用它们创建一个新的流，它具有关联的类型
string[]
，然后返回它。因此，在本例中，
map
返回一个
流。（实际上，它返回一个
流
，这很混乱，需要转换，见下文）


因此，我们只需要对新的字符串数组流调用
toArray
。但是在
流
上调用
数组
与在
数组列表
上调用它有点不同，就像我们以前做的那样。在这里，我们必须使用一个函数引用。它从以下位置获取类型：
String[]]：：new
。
new
函数的类型为
String[][]
。基本上，由于函数被调用为数组，因此它将始终是某种类型的
[]
。在我们的例子中，由于其中的数据是另一个数组，我们只需添加另一个
[]
。我不知道为什么NZT-48没有在这一方面发挥作用。我本以为对
toArray（）
的默认调用就足够了，因为它是一个流和所有内容。特别是
流
的流。有人知道为什么
map
实际返回的是
流
，而不是内部Lambda表达式返回的类型的流吗


现在我们从
mainList
流中获得了正常运行的
toArray
。我们可以很容易地将其转储到一个局部变量中：
String[]stringArray=mainList.stream…


将二维整数数组列表转换为二维基元整数数组
现在，我知道你们中的一些人要去那里。“这对ints不起作用！”就像我的情况一样。但是，它确实适用于“”，请参见上文。但是，如果您想从
Integer
的2D
ArrayList
中获得2D基元
int
数组（即，
ArrayList，我们需要一个全新的协议来处理它们。显然，高级智能并不总是意味着易于处理。因此，需要这个新的
mapToInt
来生成一个新的
流，我们可以使用它更智能的
toArray
。以及
mapToInt
i中的
i
Lambda表达式这是对
整数
到
整数
的简单解包，使用允许
int=Integer
的隐式自动解包。现在，这似乎是一件愚蠢的小事，好像智能有其局限性
String[] stringArray = Arrays.copyOf(objectArray, objectArray.length, String[].class);

String[][] array = new String[arrayList.size()][];
for (int i = 0; i < arrayList.size(); i++) {
    ArrayList<String> row = arrayList.get(i);
    array[i] = row.toArray(new String[row.size()]);
}

public String[][] toArray(List<List<String>> list) {
    String[][] r = new String[list.size()][];
    int i = 0;
    for (List<String> next : list) {
       r[i++] = next.toArray(new String[next.size()]);
    }
    return r;
}

ArrayList<ArrayList<String>> mainList = new ArrayList<ArrayList<String>>();
// populate this list here

ArrayList<ArrayList<String>> mainList = new ArrayList();
//Populate

String[][] stringArray = mainList.stream().map(u -> u.toArray(new String[0])).toArray(String[][]::new);

int[][] intArray = mainList.stream().map(  u  ->  u.stream().mapToInt(i->i).toArray()  ).toArray(int[][]::new);

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

public class ListTo2Darray {

    public String[][] toArray(List<List<?>> list) {
    String[][] r = new String[list.size()][];
    int i = 0;
    for (List<?> next : list) {
       r[i++] = next.toArray(new String[next.size()]);
    }
    return r;
}

    public static void main(String[]arg){
        String[][] sham;

        List<List<?>> mList = new ArrayList();

        List<String> a= new ArrayList();
        List<String> b= new ArrayList();
        a.add("a");  a.add("a");
        b.add("b");  b.add("b");
        mList.add(a); mList.add(b); 

        ListTo2Darray mt= new ListTo2Darray();
        sham=   mt.toArray(mList);

        System.out.println(sham[0][0]);
        System.out.println(sham[0][1]);
        System.out.println(sham[1][0]);
        System.out.println(sham[1][1]);
    }

}

queries=[[1,5,3],[4,8,7],[6,9,1]]
h=queries.size();

        for(i=0;i<h;i++){
            for(j=0;j<3;j++){
                y[i][j]= ( ( queries.get(i) ).get(j) );
            }  
        }