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. 完全展开：

    • 如果需要将整个嵌套结构中的元素展开为字符串数组，可以通过嵌套循环或流式操作实现。
相关推荐
观无2 分钟前
c#中的virtual方法
开发语言·c#
2401_840192278 分钟前
git的作用，以及和github的区别
开发语言·经验分享·git·python·devops
xcbeyond31 分钟前
Kubernetes 中 Java 应用性能调优指南：从容器化特性到 JVM 底层原理的系统化优化
java·jvm·云原生·kubernetes
紧跟先前的步伐43 分钟前
【Golang】第十一弹------反射
开发语言·后端·golang
蓝白咖啡1 小时前
华为OD机试 - 王者荣耀匹配机制 - 回溯（Java 2024 D卷 200分）
java·python·算法·华为od·机试
一人の梅雨1 小时前
西域平台关键字搜索接口开发指南
java·开发语言·数据库
Code_Geo1 小时前
pyproj 库中 Geod 类讲解
开发语言·python·geod·pyproj
大锦终1 小时前
详解list容器
c语言·开发语言·数据结构·c++·list
DA02211 小时前
C++轻量HeaderOnly的JSON库
开发语言·c++·json
triticale1 小时前
【图论】最短路径问题总结
java·开发语言·图论
热门推荐
01HTML项目一键打包工具：HTML2EXE 最新版02RAG 实践- Ollama+RagFlow 部署本地知识库03DeepSeek各版本说明与优缺点分析04PyTorch量化技术教程：第四章 PyTorch在量化交易中的应用05本地化部署AI知识库：基于Ollama+DeepSeek+AnythingLLM保姆级教程06从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑07RAG生成中的多文档动态融合及去重加权策略探讨08苍穹外卖面试总结09如何在WPS和Word/Excel中直接使用DeepSeek功能10前端使用WPS WebOffice 做在线文档预览与编辑