Java 用循环生成多个数组列表

我有大量的ArrayList，我希望能够使用for循环操作它们。如果它们被命名为p1、p2、p3。。。请注意，我如何使用循环而不是

p1.get(0);
p2.get(0);
p3.get(0);
pn.get(0);

---

将

ArrayList

s放入

ArrayList

中。在

for

循环中访问它们，然后在检索到的

ArrayList

上调用

get（0）

将

ArrayList

放在

ArrayList

中。在

for

循环中访问它们，然后在检索到的

数组列表上调用
get（0）

，您可以将它们全部放入一个列表中并循环

List<ArrayList> lists = new LinkedList<ArrayList>();
lists.add(p1);
lists.add(p2);

for ( ArrayList list : lists ) {
   list.get(0);
}

List List=newlinkedlist（）；
列表。添加（p1）；
列表。添加（p2）；
对于（ArrayList:列表）{
list.get（0）；
}

您可以将它们全部放在一个列表中，然后在上面循环

List<ArrayList> lists = new LinkedList<ArrayList>();
lists.add(p1);
lists.add(p2);

for ( ArrayList list : lists ) {
   list.get(0);
}

List List=newlinkedlist（）；
列表。添加（p1）；
列表。添加（p2）；
对于（ArrayList:列表）{
list.get（0）；
}

公共类列表示例{
公共静态void main（字符串[]args）{
列表p1=数组.asList（1,2,3,4,5）；
List p2=数组.asList（1,2,3,4,5）；
List p3=数组.asList（1,2,3,4,5）；
List lists=新建ArrayList（）；
列表。添加（p1）；
列表。添加（p2）；
列表。添加（p3）；
用于（列表：列表）{
System.out.println（list.get（0））；
}
}
}

公共类列表示例{
公共静态void main（字符串[]args）{
列表p1=数组.asList（1,2,3,4,5）；
List p2=数组.asList（1,2,3,4,5）；
List p3=数组.asList（1,2,3,4,5）；
List lists=新建ArrayList（）；
列表。添加（p1）；
列表。添加（p2）；
列表。添加（p3）；
用于（列表：列表）{
System.out.println（list.get（0））；
}
}
}

您的问题不清楚。如果您指的是如何访问循环中的四个独立阵列

for (int i = 0; i < ...; ++ i) {
    p1.get(i);
    p2.get(i);
    p3.get(i);
    pn.get(i);
}

for（int i=0；i<…；++i）{
p1.get（i）；
p2.获取（i）；
p3.get（i）；
pn.get（i）；
}

如果您的意思是有四个大小相等的数组，并且希望更方便地将数据分组在一起，那么请放弃这四个区域，使用相关字段创建一个类来存储数据，并使用其中的单个数组：

class Item {
    Whatever v1;
    Whatever v2;
    Whatever v3;
    Whatever vn;
}

ArrayList<Item> items = ...;
items.get(0);

类项目{
无论v1；
无论v2；
不管怎样；
无论vn是什么；
}
ArrayList项=。。。；
items.get（0）；

如果您的意思是这些数组的数量可变，并且希望选择动态访问哪个数组，则可以使用原始ArrayList中的ArrayList：

List<ArrayList<Whatever>> p = getListOfAllMyArrayLists();
p.get(n).get(0);

List p=getListofAllMyArrayList（）；
p、 get（n），get（0）；

如果出于某种原因（可能无法重构），您希望保留所有单独的数组，并且只希望以一种方便的方式一次访问所有数据，您可以编写一种方法来实现这一点，并将结果打包到它们自己的数组中，例如：

public List<Whatever> getAll (int x) {
    List<Whatever> values = new ArrayList<Whatever>();
    values.add(p1.get(x));
    values.add(p2.get(x));
    values.add(p3.get(x));
    values.add(pn.get(x));
    return values;
}

公共列表getAll（int x）{
列表值=新的ArrayList（）；
添加（p1.get（x））；
value.add（p2.get（x））；
添加（p3.get（x））；
添加（pn.get（x））；
返回值；
}

如果使用省略号参数，还可以实现

getAll（）

以获取数量可变的源数组

---

我希望其中一个能有所帮助。

你的问题不清楚。如果您指的是如何访问循环中的四个独立阵列

for (int i = 0; i < ...; ++ i) {
    p1.get(i);
    p2.get(i);
    p3.get(i);
    pn.get(i);
}

for（int i=0；i<…；++i）{
p1.get（i）；
p2.获取（i）；
p3.get（i）；
pn.get（i）；
}

如果您的意思是有四个大小相等的数组，并且希望更方便地将数据分组在一起，那么请放弃这四个区域，使用相关字段创建一个类来存储数据，并使用其中的单个数组：

class Item {
    Whatever v1;
    Whatever v2;
    Whatever v3;
    Whatever vn;
}

ArrayList<Item> items = ...;
items.get(0);

类项目{
无论v1；
无论v2；
不管怎样；
无论vn是什么；
}
ArrayList项=。。。；
items.get（0）；

如果您的意思是这些数组的数量可变，并且希望选择动态访问哪个数组，则可以使用原始ArrayList中的ArrayList：

List<ArrayList<Whatever>> p = getListOfAllMyArrayLists();
p.get(n).get(0);

List p=getListofAllMyArrayList（）；
p、 get（n），get（0）；

如果出于某种原因（可能无法重构），您希望保留所有单独的数组，并且只希望以一种方便的方式一次访问所有数据，您可以编写一种方法来实现这一点，并将结果打包到它们自己的数组中，例如：

public List<Whatever> getAll (int x) {
    List<Whatever> values = new ArrayList<Whatever>();
    values.add(p1.get(x));
    values.add(p2.get(x));
    values.add(p3.get(x));
    values.add(pn.get(x));
    return values;
}

公共列表getAll（int x）{
列表值=新的ArrayList（）；
添加（p1.get（x））；
value.add（p2.get（x））；
添加（p3.get（x））；
添加（pn.get（x））；
返回值；
}

如果使用省略号参数，还可以实现

getAll（）

以获取数量可变的源数组

---

我希望其中一个方法是有帮助的。

解决方法是不要这样做。使用数组/集合而不是大量的单个变量。首先，您需要一个实际的循环。到目前为止，您尝试了什么？创建一个arrayList的arrayList。解决方法是不要这样做。使用数组/集合而不是大量的单个变量。首先，您需要一个实际的循环。到目前为止您尝试了什么？创建arrayList的arrayList。