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

    • 如果需要将整个嵌套结构中的元素展开为字符串数组，可以通过嵌套循环或流式操作实现。
相关推荐
啊阿狸不会拉杆1 分钟前
第二十一章:Python-Plotly库实现数据动态可视化
开发语言·python·plotly
okok__TXF6 分钟前
Mybatis源码分析
java·后端·mybatis
滴答滴答嗒嗒滴12 分钟前
Python小练习系列 Vol.12：学生信息排序（sorted + key函数）
开发语言·python
白云如幻25 分钟前
【Java】Hibernate的一级缓存
java·hibernate
eternal__day1 小时前
Spring Boot 快速入手
java·spring boot·后端·spring·java-ee·maven
愚润求学1 小时前
【C++】vector常用方法总结
开发语言·c++·vector
天天进步20151 小时前
Python项目-基于Flask的个人博客系统设计与实现(1)
开发语言·python·flask
爱的叹息1 小时前
Spring Boot中事务状态(TransactionStatus)的核心信息及常见应用场景
java·spring boot·后端
安然无虞1 小时前
31天Python入门——第20天:魔法方法详解
开发语言·后端·爬虫·python
QQ__17646198241 小时前
Matlab安装tdms插件
开发语言·matlab·tdms插件
热门推荐
01我决定放弃搞 Java 了02DeepSeek各版本说明与优缺点分析03如何在WPS和Word/Excel中直接使用DeepSeek功能04从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑05苍穹外卖面试总结06DeepSeek R1本地化部署 Ollama + Chatbox 打造最强 AI 工具07RAG 实践- Ollama+RagFlow 部署本地知识库08本地化部署AI知识库：基于Ollama+DeepSeek+AnythingLLM保姆级教程09如何本地部署AI智能体平台，带你手搓一个AI Agent10循环神经网络RNN（含LSTM，GRU）小综述