所以我有:
ArrayList<ArrayList<String>>
其中包含x个包含另外y个字符串的ArrayLists。演示:
Index 0:
String 1
String 2
String 3
Index 1:
String 4
Index 2:
Index 3:
String 5
String 6
其中index指的是包含字符串的数组索引。
如何将其转换为2D数组,如下所示:
{{String1, String2, String3},{String4}, {}, {String5, String6}}
非常感谢你。
答案 0 :(得分:28)
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()]);
}
其中arrayList
是您的ArrayList<ArrayList<String>>
(或任何List<List<String>>
,请相应更改for
循环中的第一行
答案 1 :(得分:23)
欢迎来到Java 8的世界!
只花了我一整夜都没睡觉才能学会写这一条令人毛骨悚然的代码所需要的东西。我确定它已经出现在某个地方,但我无法找到它。所以,我分享我的研究时间和时间,享受。活泉!
假设:
ArrayList<ArrayList<String>> mainList = new ArrayList<ArrayList<String>>();
// populate this list here
(或者,相反,在Java 8中:
ArrayList<ArrayList<String>> mainList = new ArrayList();
//Populate
)
然后您只需要:
String[][] stringArray = mainList.stream().map(u -> u.toArray(new String[0])).toArray(String[][]::new);
的Bam!一行。
我不确定与其他选项相比有多快。但这就是它的工作原理:
获取mainList
2D ArrayList的流。这个流有点像一个与LinkedList连接的Vector,他们有一个孩子。那个孩子,在以后的生活中,对某些NZT-48进行了注意。我离题了; mainList.stream()
正在返回ArrayList<String>
个元素的流。或者说甚至更加诙谐:mainList.stream()
返回Stream<ArrayList<String>>
,排序。
调用该流上的.map
函数,该函数将返回一个新流,其内容与传递给map
的参数指定的新类型相匹配。这个map
函数将为我们转换流中的每个元素。它有一个内置的foreach
语句。为了做到这一点; map
函数将lambda表达式作为其参数。 Lambda expression就像一个简单的内联单行函数。其中有两种数据类型gettin' Jiggy wit it。首先是调用它的流中的数据类型(mainList.stream()
)。下一个类型是它将其映射到的数据类型,它位于lambda表达式的右半部分:u -> u.toArray(new String[0])
。这里u
是您选择的标识符,就像使用foreach
语句一样。上半部分如此声明:u ->
。和foreach
一样,变量u
现在将成为流中迭代流的每个元素。因此,u
是原始流的元素所属的数据类型,因为是它们。 Lambda表达式的右半部分显示了如何处理每个元素:u.toArray(new String[0])
。将结果存储在新流中的合法位置。在这种情况下,我们将其转换为String[]
..因为毕竟,这是String
的二维数组...或者更确切地说,从代码中的这一点开始,String[]
的一维数组(字符串数组)。请注意,u
最终是ArrayList
。注意,从toArray
对象调用ArrayList
将创建一个传入其中的新类型数组。在这里,我们传递new String[0]
。因此,它创建一个类型为String[]
的新数组,其长度等于ArrayList u
的长度。然后它使用ArrayList
的内容填充这个新的字符串数组并返回它。这使得Lambda表达式返回map
。然后,map
收集这些字符串数组并使用它们创建新流,它具有关联的类型String[]
,然后返回它。因此,在这种情况下,map
会返回Stream<String[]>
。 (好吧,实际上它会返回一个Stream<Object[]>
,这会令人困惑,需要转换,见下文)
因此我们只需要在新的字符串数组上调用toArray
。但是,如前所述,在toArray
上调用Stream<Object[]>
与在ArrayList<String>
上调用String[][]::new
略有不同。在这里,我们必须使用函数引用令人困惑的事情。它抓住了这个类型:new
。 String[][]
函数的类型为[]
。基本上,由于该函数被称为 toArray ,它将永远是某种[]
。在我们的例子中,由于里面的数据是另一个数组,我们只是添加另一个toArray()
。我不确定为什么NZT-48不会在这个上工作。我本来期望默认调用Stream<String[]>
就足够了,看到它是一个流和所有。特定map
的流。任何人都知道为什么Stream<Object[]>
实际返回toArray
而不是Lambda表达式返回的类型的流?
现在我们从mainList
信息流中获得了String[][] stringArray = mainList.stream...
。我们可以很容易地将它转储到局部变量中:int
现在,我知道有些人在外面。 &#34;这不适用于整数!&#34;就像我的情况一样。但它确实适用于&#34; Ents&#34;,见上文。但是,如果您想要ArrayList
的{{1}}(即Integer
)中的2D原始ArrayList<ArrayList<Integer>>
数组。你必须改变中间[地球]的映射。请记住,ArrayLists不具有原始类型。因此,您无法在toArray
上致电ArrayList<Integer>
并希望获得int[]
。您需要再次将其映射出来。
int[][] intArray = mainList.stream().map( u -> u.stream().mapToInt(i->i).toArray() ).toArray(int[][]::new);
为了便于阅读,我试图将其分开。但是你可以在这里看到我们必须再次完成相同的整个映射过程。这次我们不能简单地在ArrayList toArray
上调用u
;与上面的例子一样。我们在toArray
而不是Stream
上呼叫ArrayList
。因此,出于某种原因,我们不必将其传递给#34;类型&#34;,我认为它服用大脑类固醇。因此,我们可以采用默认选项;在那里它受到了NZT-48的打击,并为我们这个[运行]时间找出了明显的结果。我不确定为什么它不能在上面的例子中做到这一点。哦,没错...... ArrayLists不像Streams那样服用NZT-48。等等......我甚至在这里谈论什么?
Annnyhoow,因为溪流非常聪明。与Sheldon一样,我们需要一个全新的协议来处理它们。显然,先进的智能并不总是意味着易于处理。因此,需要这个新的mapToInt
来制作一个新的Stream
,我们可以使用它toArray
。 i->i
中的mapToInt
Lambda表达式是Integer
到int
的简单取消装箱,使用允许int = Integer
的隐式自动取消装箱。现在,这似乎是一件愚蠢的事情,好像情报有其局限。在冒险中学习所有这些:我实际上尝试使用mapToInt(null)
因为我期望默认行为。不是争论!! (咳嗽 Sheldon 咳嗽)然后我说出我最好的Husker山谷女孩口音,&#34; Afterall,被称为mapToInt
,我猜想,就像84%的时间(42 x2)一样,通过i->i
,就像每个人一样,所以就像,omgawd!& #34;毋庸置疑,我感觉有点......就像.. this guy。不知道为什么它不会这样工作!
嗯,我是红眼,半昏迷,半睡半醒。我可能犯了一些错误;请把它们拖出去,这样我就可以解决它们,让我知道是否有更好的方法!
PT
答案 2 :(得分:5)
您可以使用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();
您可以找到有关toArray()
here.
答案 3 :(得分:1)
ArrayList<ArrayList<String>> list= new ArrayList<ArrayList<String>>();
ArrayList<String> a = new ArrayList<String>();
ArrayList<String> b = new ArrayList<String>();
a.add("Hello");
b.add("Hell");
list.add(a);
list.add(b);
Object[][] array = new Object[list.size()][];
Iterator<ArrayList<String>> iterator = list.iterator();
int i = 0;
while(iterator.hasNext()){
array[i] = iterator.next().toArray();
}
您可以使用以下代码段将Object []转换为String []
String[] stringArray = Arrays.copyOf(objectArray, objectArray.length, String[].class);
答案 4 :(得分:1)
例如:
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;
}
答案 5 :(得分:0)
这个完整的迷你程序代码以非常不言自明的方式回答了这个问题。只需粘贴并运行它:
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]);
}
}
答案 6 :(得分:0)
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) );
}
}
它会做的是在这个语句的 y[i][j] 处首先 query.get(i) 将选择列表的第一个块,即在 i=0 时它将选择 [1,5,3]然后在 j=0 时,它将从 [1,5,3] 中选择 1,依此类推..
循环说明: y[][]=[ 1 5 3 4 8 7 6 9 1 ]
注意:用给定的数组替换查询。
请告诉我它是否有效,或者我应该提供另一种方法来解决问题