JAVA 嵌套列表初始化和转字符串
在 Java 中，创建嵌套列表（List<List<Integer>>）有多种方法，根据需求可以选择不同的实现方式。以下是几种常见方法：
1. 使用 List.of()
List.of() 是 Java 9 引入的方法，用于创建不可变列表。这种方法简洁易用，但创建的子列表不能被修改（不可变）。
示例
import java.util.List;
public class NestedListUsingListOf {
public static void main(String[] args) {
List<List<Integer>> myList = List.of(
List.of(1, 2),
List.of(3, 4),
List.of(5, 6, 7)
);
System.out.println(myList); // 输出: [[1, 2], [3, 4], [5, 6, 7]]
}
}
2. 使用 Arrays.asList()
Arrays.asList() 用于创建可变的列表，子列表可以修改（添加、删除元素）。不过需要注意，Arrays.asList() 返回的是固定大小的列表，因此不能增删元素，只能修改内容。
示例
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class NestedListUsingAsList {
public static void main(String[] args) {
List<List<Integer>> myList = new ArrayList<>();
myList.add(Arrays.asList(1, 2));
myList.add(Arrays.asList(3, 4));
myList.add(Arrays.asList(5, 6, 7));
System.out.println(myList); // 输出: [[1, 2], [3, 4], [5, 6, 7]]
}
}
3. 使用 new ArrayList<>() 手动创建
如果需要完全的可变性（包括增删子列表或修改子列表内容），推荐使用 new ArrayList<>()。这种方法适合需要对列表进行动态修改的场景。
示例
import java.util.ArrayList;
import java.util.List;
public class NestedListUsingArrayList {
public static void main(String[] args) {
List<List<Integer>> myList = new ArrayList<>();
List<Integer> innerList1 = new ArrayList<>();
innerList1.add(1);
innerList1.add(2);
List<Integer> innerList2 = new ArrayList<>();
innerList2.add(3);
innerList2.add(4);
List<Integer> innerList3 = new ArrayList<>();
innerList3.add(5);
innerList3.add(6);
innerList3.add(7);
myList.add(innerList1);
myList.add(innerList2);
myList.add(innerList3);
System.out.println(myList); // 输出: [[1, 2], [3, 4], [5, 6, 7]]
}
}
4. 使用双重循环初始化
如果嵌套列表的内容可以通过某种规律生成，可以使用循环动态创建。
示例
import java.util.ArrayList;
import java.util.List;
public class NestedListUsingLoops {
public static void main(String[] args) {
List<List<Integer>> myList = new ArrayList<>();
for (int i = 0; i < 3; i++) {
List<Integer> innerList = new ArrayList<>();
for (int j = 1; j <= 2; j++) {
innerList.add(i * 2 + j);
}
myList.add(innerList);
}
System.out.println(myList); // 输出: [[1, 2], [3, 4], [5, 6]]
}
}
5. 使用流式操作（Java 8+）
利用 Java 的流（Stream API）可以简化嵌套列表的创建，尤其是当需要动态生成数据时。
示例
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
public class NestedListUsingStreams {
public static void main(String[] args) {
List<List<Integer>> myList = IntStream.range(0, 3)
.mapToObj(i -> IntStream.range(1, 3)
.mapToObj(j -> i * 2 + j)
.collect(Collectors.toList()))
.collect(Collectors.toList());
System.out.println(myList); // 输出: [[1, 2], [3, 4], [5, 6]]
}
}
总结
| 方法 | 子列表是否可变 | 嵌套列表是否可变 | 使用场景 |
|---|---|---|---|
List.of() | 不可变 | 不可变 | 快速创建小规模静态嵌套列表 |
Arrays.asList() | 可变（内容） | 可变（大小固定） | 快速创建静态嵌套列表，子列表可以修改内容 |
new ArrayList<>() | 可变 | 可变 | 动态创建嵌套列表，需要添加、删除操作 |
| 双重循环初始化 | 可变 | 可变 | 动态生成内容有规律的嵌套列表 |
| 流式操作（Stream API） | 可变 | 可变 | 大规模数据初始化，代码简洁优雅 |
List 的 toString() 方法确实可以直接用于将列表转换为字符串表示，无需调用额外的方法。但是如果你不仅仅想打印，而是需要将其结果保存到一个字符串数组或其他数据结构中，仍然可以通过 toString() 方法配合进一步的操作实现。
示例 1：直接将 List 转为字符串并保存到单个字符串变量
import java.util.ArrayList;
import java.util.List;
public class ListToStringExample {
public static void main(String[] args) {
List<List<Integer>> myList = new ArrayList<>();
myList.add(List.of(1, 2));
myList.add(List.of(3, 4));
// 使用 toString() 方法将其保存为字符串
String result = myList.toString();
// 输出保存的字符串
System.out.println("String representation: " + result);
}
}
输出：
String representation: [[1, 2], [3, 4]]
示例 2：将嵌套列表的每个子列表转为字符串并存储在字符串数组中
如果你希望将嵌套列表的每个子列表的字符串表示单独存储到一个字符串数组中，可以遍历嵌套列表，逐一调用 toString()：
import java.util.ArrayList;
import java.util.List;
public class ListToStringArrayExample {
public static void main(String[] args) {
List<List<Integer>> myList = new ArrayList<>();
myList.add(List.of(1, 2));
myList.add(List.of(3, 4));
myList.add(List.of(5, 6, 7));
// 创建一个字符串数组保存子列表的字符串表示
String[] stringArray = new String[myList.size()];
for (int i = 0; i < myList.size(); i++) {
stringArray[i] = myList.get(i).toString(); // 子列表转为字符串
}
// 输出字符串数组内容
for (String s : stringArray) {
System.out.println(s);
}
}
}
输出：
[1, 2]
[3, 4]
[5, 6, 7]
示例 3：将整个嵌套列表展开为字符串数组
如果需要将整个嵌套列表展开为字符串数组，包含所有内部元素的字符串表示，可以使用嵌套循环或流式操作：
方式 1：嵌套循环
import java.util.ArrayList;
import java.util.List;
public class NestedListToFlatStringArray {
public static void main(String[] args) {
List<List<Integer>> myList = new ArrayList<>();
myList.add(List.of(1, 2));
myList.add(List.of(3, 4));
myList.add(List.of(5, 6, 7));
// 展开嵌套列表到字符串数组
List<String> flatList = new ArrayList<>();
for (List<Integer> innerList : myList) {
for (Integer num : innerList) {
flatList.add(num.toString());
}
}
// 转为字符串数组
String[] stringArray = flatList.toArray(new String[0]);
// 输出结果
for (String s : stringArray) {
System.out.println(s);
}
}
}
输出：
1
2
3
4
5
6
7
方式 2：使用流式操作
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class StreamNestedListToFlatStringArray {
public static void main(String[] args) {
List<List<Integer>> myList = new ArrayList<>();
myList.add(List.of(1, 2));
myList.add(List.of(3, 4));
myList.add(List.of(5, 6, 7));
// 使用流展开嵌套列表并转为字符串数组
String[] stringArray = myList.stream()
.flatMap(List::stream)
.map(Object::toString)
.toArray(String[]::new);
// 输出结果
for (String s : stringArray) {
System.out.println(s);
}
}
}
总结
-
直接转换为字符串：
- 使用
toString()可以将整个列表的字符串表示保存到一个单独的字符串变量中。 - 示例：
String result = myList.toString();
- 使用
-
部分保存：
- 如果需要将每个子列表单独转换为字符串并保存，可以遍历嵌套列表，逐一调用
toString()，存入字符串数组。
- 如果需要将每个子列表单独转换为字符串并保存，可以遍历嵌套列表，逐一调用
-
完全展开：
- 如果需要将整个嵌套结构中的元素展开为字符串数组，可以通过嵌套循环或流式操作实现。