在 Java 中，一个 List 可以包含另一个 List，这被称为嵌套列表（Nested List），以下是几种实现方式及相关示例：
使用 List<List<T>>（最常见）
直接使用 Java 集合框架中的 ArrayList 或 LinkedList 作为外层和内层列表的类型。
示例代码：
import java.util.ArrayList;
import java.util.List;
public class NestedListExample {
public static void main(String[] args) {
// 创建外层 List
List<List<Integer>> outerList = new ArrayList<>();
// 创建第一个内层 List 并添加元素
List<Integer> innerList1 = new ArrayList<>();
innerList1.add(1);
innerList1.add(2);
innerList1.add(3);
// 创建第二个内层 List 并添加元素
List<Integer> innerList2 = new ArrayList<>();
innerList2.add(4);
innerList2.add(5);
// 将内层 List 添加到外层 List
outerList.add(innerList1);
outerList.add(innerList2);
// 遍历嵌套 List
for (List<Integer> innerList : outerList) {
for (Integer num : innerList) {
System.out.print(num + " ");
}
System.out.println();
}
}
}
输出：
1 2 3
4 5 使用自定义类（更结构化）
如果嵌套列表需要额外的逻辑或属性,可以定义一个自定义类来封装内层列表。
示例代码：
import java.util.ArrayList;
import java.util.List;
class InnerListContainer {
private List<Integer> numbers;
public InnerListContainer() {
this.numbers = new ArrayList<>();
}
public void addNumber(int num) {
numbers.add(num);
}
public List<Integer> getNumbers() {
return numbers;
}
}
public class CustomNestedListExample {
public static void main(String[] args) {
List<InnerListContainer> outerList = new ArrayList<>();
InnerListContainer container1 = new InnerListContainer();
container1.addNumber(10);
container1.addNumber(20);
InnerListContainer container2 = new InnerListContainer();
container2.addNumber(30);
outerList.add(container1);
outerList.add(container2);
for (InnerListContainer container : outerList) {
for (Integer num : container.getNumbers()) {
System.out.print(num + " ");
}
System.out.println();
}
}
}
输出：
10 20
30 使用泛型（更灵活）
可以通过泛型支持不同类型的嵌套列表。
示例代码：
import java.util.ArrayList;
import java.util.List;
public class GenericNestedListExample {
public static void main(String[] args) {
List<List<String>> stringList = new ArrayList<>();
List<List<Double>> doubleList = new ArrayList<>();
List<String> names = new ArrayList<>();
names.add("Alice");
names.add("Bob");
List<Double> prices = new ArrayList<>();
prices.add(19.99);
prices.add(29.99);
stringList.add(names);
doubleList.add(prices);
// 打印嵌套 List
System.out.println("String List: " + stringList);
System.out.println("Double List: " + doubleList);
}
}
输出：
String List: [[Alice, Bob]]
Double List: [[19.99, 29.99]]注意事项：
- 空指针异常：如果内层列表可能为
null，需检查：if (outerList != null && outerList.get(0) != null) { // 安全访问 } - 性能：频繁操作嵌套列表时，考虑使用更高效的数据结构（如
LinkedList或CopyOnWriteArrayList）。 - 不可变性：如果需要不可变列表，可以使用
Collections.unmodifiableList()。
- 简单嵌套：直接使用
List<List<T>>。 - 复杂逻辑：通过自定义类封装内层列表。
- 类型安全：利用泛型支持多种数据类型。
根据需求选择合适的方式即可！
