【新手向】Java中List<Integer>, Integer[], int[]的相互转换

Java数组与List互转
本文介绍如何在Java中轻松实现数组与List之间的转换,利用Java8的流操作,包括int[]与List&lt;Integer&gt;、String[]与List&lt;String&gt;的相互转换,简化编程流程。

相信新手们在学习Java的过程中都会遇到和我一样的问题:想要把List<Integer>和int[]相互转换太麻烦了。

List<String>和String[]也同理。难道每次非得写一个循环遍历吗?其实一步就可以搞定。

本文涉及到一些Java8的特性。如果没有接触过就先学会怎么用,然后再细细研究。

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        int[] data = {4, 5, 3, 6, 2, 5, 1};

        // int[] 转 List<Integer>
        List<Integer> list1 = Arrays.stream(data).boxed().collect(Collectors.toList());
        // Arrays.stream(arr) 可以替换成IntStream.of(arr)。
        // 1.使用Arrays.stream将int[]转换成IntStream。
        // 2.使用IntStream中的boxed()装箱。将IntStream转换成Stream<Integer>。
        // 3.使用Stream的collect(),将Stream<T>转换成List<T>,因此正是List<Integer>。

        // int[] 转 Integer[]
        Integer[] integers1 = Arrays.stream(data).boxed().toArray(Integer[]::new);
        // 前两步同上,此时是Stream<Integer>。
        // 然后使用Stream的toArray,传入IntFunction<A[]> generator。
        // 这样就可以返回Integer数组。
        // 不然默认是Object[]。

        // List<Integer> 转 Integer[]
        Integer[] integers2 = list1.toArray(new Integer[0]);
        //  调用toArray。传入参数T[] a。这种用法是目前推荐的。
        // List<String>转String[]也同理。

        // List<Integer> 转 int[]
        int[] arr1 = list1.stream().mapToInt(Integer::valueOf).toArray();
        // 想要转换成int[]类型,就得先转成IntStream。
        // 这里就通过mapToInt()把Stream<Integer>调用Integer::valueOf来转成IntStream
        // 而IntStream中默认toArray()转成int[]。

        // Integer[] 转 int[]
        int[] arr2 = Arrays.stream(integers1).mapToInt(Integer::valueOf).toArray();
        // 思路同上。先将Integer[]转成Stream<Integer>,再转成IntStream。

        // Integer[] 转 List<Integer>
        List<Integer> list2 = Arrays.asList(integers1);
        // 最简单的方式。String[]转List<String>也同理。

        // 同理
        String[] strings1 = {"a", "b", "c"};
        // String[] 转 List<String>
        List<String> list3 = Arrays.asList(strings1);
        // List<String> 转 String[]
        String[] strings2 = list3.toArray(new String[0]);

    }
}

 由此可见,流操作还是很方便的。我对这些知识的掌握也不深,就不误人子弟了,只是给刚接触的人提供一个思考的方向。

<think>我们正在讨论Java中的两种泛型列表类型:`List<Integer>`和`List<List<Integer>>`。这两种类型在结构上存在层级差异,理解它们的区别对于处理嵌套数据结构(如矩阵、树等)至关重要。 ### 一、类型定义与结构差异 1. **`List<Integer>`** - 存储整数对象的**一维序列**,每个元素是`Integer`类型 - 内存结构示意: ``` [ Integer(1) | Integer(2) | Integer(3) | ... ] ``` 2. **`List<List<Integer>>`** - 存储多个`List<Integer>`对象的**二维集合**,每个元素本身是一个整数列表 - 内存结构示意: ``` [ [ Integer(1), Integer(2) ], // List<Integer> 实例1 [ Integer(3), Integer(4) ], // List<Integer> 实例2 ... ] ``` ### 二、应用场景对比 | 类型 | 典型应用场景 | 示例 | |---------------------|----------------------------------|-------------------------------| | `List<Integer>` | 一维数据序列 | 学生成绩列表、传感器读数流 | | `List<List<Integer>>` | 二维数据结构 | 矩阵、棋盘状态、树结构的层级表示 | **示例1:矩阵乘法** 使用`List<List<Integer>>`表示$M×N$矩阵: ```java // 定义3x3矩阵 List<List<Integer>> matrix = List.of( List.of(1, 2, 3), List.of(4, 5, 6), List.of(7, 8, 9) ); // 访问元素(行=1,列=2) int element = matrix.get(1).get(2); // 返回6 ``` **示例2:二叉树层序遍历** `List<List<Integer>>`存储每层节点值: ```java /* 二叉树: 1 / \ 2 3 / \ \ 4 5 6 */ List<List<Integer>> levelOrder = List.of( List.of(1), // 根节点 List.of(2, 3), // 第二层 List.of(4, 5, 6) // 第三层 ); ``` ### 三、内存与性能特性 | 特性 | `List<Integer>` | `List<List<Integer>>` | |---------------------|--------------------------|----------------------------| | **元素类型** | `Integer`对象 | `List<Integer>`对象引用 | | **内存开销** | 较低 (直接存储数据) | 较高 (额外存储子列表引用) | | **遍历复杂度** | $O(n)$ | $O(n×m)$ (n行数,m列数) | | **随机访问** | `list.get(i)` | `outer.get(i).get(j)` | > 注意:嵌套列表可能因子列表长度不同形成**不规则二维结构**(非矩阵),例如: > ```java > List<List<Integer>> jagged = List.of( > List.of(1), > List.of(2, 3, 4), // 第一行3列,第二行1列 > List.of(5) > ); > ``` ### 四、操作差异对比 1. **初始化** - `List<Integer>`: ```java List<Integer> flatList = new ArrayList<>(Arrays.asList(1, 2, 3)); ``` - `List<List<Integer>>`: ```java List<List<Integer>> nestedList = new ArrayList<>(); nestedList.add(Arrays.asList(1, 2)); nestedList.add(Arrays.asList(3, 4, 5)); ``` 2. **元素添加** - 向一维列表添加整数: ```java flatList.add(6); // ✅ 合法 ``` - 向二维列表添加整数需通过子列表: ```java nestedList.get(0).add(7); // 修改第一行:变为[1,2,7] // nestedList.add(8); // ❌ 编译错误:类型不匹配 ``` 3. **遍历操作** - 一维列表单层遍历: ```java for (int num : flatList) { System.out.println(num); } ``` - 二维列表嵌套遍历: ```java for (List<Integer> row : nestedList) { for (int num : row) { System.out.print(num + " "); } System.out.println(); } ``` ### 五、设计意义 - **`List<Integer>`**: 基础线性结构,适用于**标量数据集合**处理 - **`List<List<Integer>>`**: 实现**数据分层组织**,常用于: - 多维数据表达(如图像像素矩阵) - 树/图结构的层级表示(如二叉树的层序遍历结果) - 动态行列表格(如CSV解析结果) > 在Java集合框架中,这种嵌套设计通过泛型组合实现了类型安全的复杂数据结构建模[^1]。 §§相关问题§§ 1. 如何在`List<List<Integer>>`中实现矩阵置操作? 2. `List<List<Integer>>`与`Integer[][]`在性能上有何差异? 3. 处理不规则二维列表时应注意哪些边界条件? 4. Java中是否有替代`List<List<Integer>>`的更高效多维数据结构?</think>### Java 中 `List<Integer>` 与 `List<List<Integer>>` 的区别详解 #### 一、核心区别:**数据结构层级** 1. **`List<Integer>`** - 一维整数列表,存储**单个整数元素** - 示例:`[1, 2, 3, 4]` - 内存结构: ``` [ Integer(1) | Integer(2) | Integer(3) | ... ] ``` 2. **`List<List<Integer>>`** - 二维整数列表,存储**多个整数列表** - 示例:`[[1,2], [3,4,5], [6]]` - 内存结构: ``` [ [ Integer(1), Integer(2) ], // 子列表1 [ Integer(3), Integer(4), Integer(5) ], // 子列表2 [ Integer(6) ] // 子列表3 ] ``` #### 二、应用场景对比 | 类型 | 典型应用场景 | 示例 | |---------------------|----------------------------------|-------------------------------| | `List<Integer>` | 一维数据序列 | 学生成绩列表、传感器读数流 | | `List<List<Integer>>` | 二维数据结构 | 矩阵、树结构层级、Excel表格数据 | **示例代码** ```java // 一维列表: 存储班级分数 List<Integer> scores = Arrays.asList(90, 85, 78); // 二维列表: 存储多个班级的分数 List<List<Integer>> allClassScores = Arrays.asList( Arrays.asList(90, 85, 78), // 班级1 Arrays.asList(88, 92, 75) // 班级2 ); ``` #### 三、操作差异对比 1. **元素访问** ```java // List<Integer> int firstScore = scores.get(0); // 直接获取整数 // List<List<Integer>> List<Integer> class1 = allClassScores.get(0); // 获取子列表 int class1FirstScore = class1.get(0); // 再获取整数 ``` 2. **添加元素** ```java // List<Integer> 添加单个整数 scores.add(95); // List<List<Integer>> 添加整列表 List<Integer> newClass = new ArrayList<>(Arrays.asList(80, 85)); allClassScores.add(newClass); ``` 3. **遍历复杂度** - `List<Integer>`: 单层循环 $O(n)$ ```java for (int score : scores) { ... } ``` - `List<List<Integer>>`: 嵌套循环 $O(n \times m)$ ```java for (List<Integer> classScores : allClassScores) { for (int score : classScores) { ... } } ``` #### 四、内存特性对比 | 特性 | `List<Integer>` | `List<List<Integer>>` | |---------------------|--------------------------|----------------------------| | **存储内容** | 直接存储 `Integer` 对象 | 存储 `List<Integer>` 引用 | | **内存开销** | 较低 (仅数据+列表结构) | 较高 (额外子列表引用开销) | | **数据连续性** | 连续存储整数 | 子列表内存可能不连续 | #### 五、设计意义 - **`List<Integer>`**: 基础线性结构,适用于**标量数据集合**处理 - **`List<List<Integer>>`**: 实现**数据分组**或**层级关系**,例如: - 矩阵运算:每行作为一个子列表 - 树结构遍历:每层节点作为一个子列表 - 表格数据:每行对应一个子列表 > 通过泛型嵌套,`List<List<Integer>>` 在保持类型安全的同时,实现了复杂数据结构的灵活建模[^1]。
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值