JAVA 嵌套列表初始化和转字符串

2301_793069822025-01-13 12:13

在 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);
        }
    }
}

总结

  1. 直接转换为字符串：

    • 使用 toString() 可以将整个列表的字符串表示保存到一个单独的字符串变量中。
    • 示例：String result = myList.toString();

  2. 部分保存：

    • 如果需要将每个子列表单独转换为字符串并保存，可以遍历嵌套列表，逐一调用 toString()，存入字符串数组。

  3. 完全展开：

    • 如果需要将整个嵌套结构中的元素展开为字符串数组，可以通过嵌套循环或流式操作实现。
相关推荐
异常君几秒前
线程池隐患解析：为何阿里巴巴拒绝 Executors
java·后端·代码规范
Java技术小馆6 分钟前
SpringBoot中暗藏的设计模式
java·面试·架构
xiguolangzi7 分钟前
《springBoot3 中使用redis》
java
꧁坚持很酷꧂9 分钟前
配置Ubuntu18.04中的Qt Creator为中文（图文详解）
开发语言·qt·ubuntu
李菠菜14 分钟前
非SpringBoot环境下Jedis集群操作Redis实战指南
java·redis
不当菜虚困26 分钟前
JAVA设计模式——（四）门面模式
java·开发语言·设计模式
ruyingcai66666626 分钟前
用python进行OCR识别
开发语言·python·ocr
m0Java门徒34 分钟前
面向对象编程核心：封装、继承、多态与 static 关键字深度解析
java·运维·开发语言·intellij-idea·idea
liuweidong080237 分钟前
【Pandas】pandas DataFrame radd
开发语言·python·pandas
无心水1 小时前
【Java面试笔记：基础】8.对比Vector、ArrayList、LinkedList有何区别？
java·笔记·面试·vector·arraylist·linkedlist
热门推荐
01KGG转MP3工具|非KGM文件|解密音频02从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑03我决定放弃搞 Java 了04Coze扣子平台完整体验和实践（附国内和国际版对比）05YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】06DeepSeek各版本说明与优缺点分析07yolov8，yolo11，yolo12 服务器训练到部署全流程 笔记08苍穹外卖面试总结09如何在WPS和Word/Excel中直接使用DeepSeek功能10【2025年最新】OpenWrt 更换国内源的指南（图形界面版)