​List,Map多层循环嵌套及其理解​

已于 2023-06-11 11:26:27 修改
阅读量851 收藏
点赞数 1
分类专栏： Java基础 文章标签： java spring maven
于 2023-04-23 08:50:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wy971744839/article/details/130313937
版权

       先简答贴下POM

先简答贴下POM

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.7.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example.DemoCrud</groupId>
    <artifactId>democurd</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>democurd</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <!-- mybatis整合Springboot -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.0</version>
        </dependency>

        <dependency>
            <!--           maven 添加json-->
            <groupId>net.sf.json-lib</groupId>
            <artifactId>json-lib</artifactId>
            <version>2.4</version>
        </dependency>
        <!-- 引入org.json所需依赖 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.70</version>
        </dependency>
        <dependency>
            <groupId>org.webjars</groupId>
            <artifactId>jquery</artifactId>
            <version>3.3.0</version>
        </dependency>
        <!--bootstrap-webjar-->
        <dependency>
            <groupId>org.webjars</groupId>
            <artifactId>bootstrap</artifactId>
            <version>4.0.0</version>
        </dependency>
        <!--配置文件注入时使用后会有提示-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.18</version>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.3.1</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.12</version>
            <scope>provided</scope>
        </dependency>
        <!-- https://mvnrepository.com/artifact/oracle/oracle-jdbc -->
        <dependency>
            <groupId>com.oracle.ojdbc</groupId>
            <artifactId>ojdbc8</artifactId>
            <version>19.3.0.0</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.47</version>
        </dependency>


        <!-- Druid 数据源依赖，集成了 Spring boot ，方便配置 druid 属性 -->
        <!-- https://mvnrepository.com/artifact/com.alibaba/druid-spring-boot-starter -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.2.8</version>
        </dependency>

        <!-- Mysql 数据库驱动，spring boot 2.1.3 时，mysql 驱动版本为 8.0.15 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>

        <!-- 引入 Spring Data JPA，JPA 组件内部会依赖 JDBC 组件，JDBC 组件内部默认依赖的是 HikariCP 数据源-->
        <!--切换 druid 数据源时，HikariCP 依赖可以移除掉，不移除时也不影响-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>

        <!--引用 log4j2 spring boot 启动器，内部依赖了 slf4j、log4j；排除项目中的 logback-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-log4j2</artifactId>
        </dependency>


    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

公共实体类

@Data
@Builder
public class Student {
    private Integer age;
    private String name;
    private Boolean sex; //true:男  false：女
}

单层循环数据存取List，Map

package com.example.democrud.democurd.Prototype.demo01;

import lombok.Builder;
import lombok.Data;
import org.thymeleaf.expression.Lists;

import java.util.*;
import java.util.stream.Collectors;

public class ListAndMapDemo {

    public static void main(String[] args) {
        List<Student> list = stduentInit();
        //取出年龄大于等于20岁的
         getAge20(list);

        //拼接字符串 马丹1,马丹2,马丹3,马丹4,马丹5
        // getStringName(list);

        //拼接字符串取年龄 10,15,20,25,30
        //  getAge(list);

        //根据年龄分组 10,10,20,20, ....
        //ageLimi(list);
    }

    /**
     * 根据年龄分组 10,10,20,20, ....
     *
     * @param list
     */
    public static void ageLimi(List<Student> list) {
        //根据年龄分组
        Map<String, List<Student>> map = new HashMap<>();
        for (Student student : list) {
            List<Student> students = map.get(student.getAge().toString());
            if (students == null) {
                students = new ArrayList<>();
            }
            students.add(student);
            map.put(student.getAge().toString(), students);
        }
        System.out.println("优化前：" + map);

        Map<Integer, List<Student>> collect = list.stream().collect(Collectors.groupingBy(Student::getAge));
        System.out.println("优化前：" + collect);
    }


    /**
     * 拼接字符串取年龄 10,15,20,25,30
     *
     * @param list
     */
    public static void getAge(List<Student> list) {
        // 无法处理空
        //  String collect = list.stream().map(v -> v.getAge().toString()).collect(Collectors.joining(","));
        //  System.out.println("无法处理空"+collect);


        String collect1 = list.stream().filter(v -> v.getAge() != null).map(Student::getAge).map(String::valueOf).collect(Collectors.joining(","));
        System.out.println("可以处理优化前" + collect1);

        String collect2 = list.stream().filter(v -> !Objects.isNull(v.getAge())).map(Student::getAge).map(String::valueOf).collect(Collectors.joining(","));
        System.out.println("可以处理优化后" + collect2);

    }


    /**
     * 拼接字符串 马丹1,马丹2,马丹3,马丹4,马丹5
     *
     * @param list
     */
    public static void getStringName(List<Student> list) {
        StringBuffer buffer = new StringBuffer();
        for (Student student : list) {
            buffer.append(student.getName());
            buffer.append(",");
        }
        String substring = buffer.toString().substring(0, buffer.toString().length() - 1);
        System.out.println("优化前：" + substring);

        String collect = list.stream().map(v -> v.getName()).collect(Collectors.joining(","));
        System.out.println("优化后：" + collect);
    }

    /**
     * 取出年龄大于等于20岁的
     */
    public static void getAge20(List<Student> list) {
        //实现一
        int ages = 20;
        List<Student> list1 = new ArrayList<Student>();

        for (Student student5 : list) {
            if (student5.getAge() >= ages) {
                list1.add(student5);
            }
        }
        System.out.println("优化前：" + list1);

        //实现二
        list = list.stream().filter(v -> v.getAge() >= 20).collect(Collectors.toList());
        System.out.println("优化后：" + list);
    }

    /**
     * 初始化list对象
     */
    public static List<Student> stduentInit() {
        List<Student> list = new ArrayList<Student>();
        //  Student student = new Student(null, "马丹1", true);
        Student student = new Student(10, "马丹1", true);
        Student student1 = new Student(20, "马丹2", false);
        Student student2 = new Student(10, "马丹3", true);
        Student student3 = new Student(10, "马丹4", false);
        Student student4 = new Student(20, "马丹5", true);
        list.add(student);
        list.add(student1);
        list.add(student2);
        list.add(student3);
        list.add(student4);
        return list;

    }
}

运行效果一一进行展示：

1.取出年龄大于等于20岁的

 //取出年龄大于等于20岁的
        getAge20(list);     

List原始数据==>[Student(age=10, name=马丹1, sex=true), Student(age=20, name=马丹2, sex=false), Student(age=10, name=马丹3, sex=true), Student(age=10, name=马丹4, sex=false), Student(age=20, name=马丹5, sex=true)]
优化前：[Student(age=20, name=马丹2, sex=false), Student(age=20, name=马丹5, sex=true)]
优化后：[Student(age=20, name=马丹2, sex=false), Student(age=20, name=马丹5, sex=true)]

在这里插入图片描述

2.拼接字符串 马丹1,马丹2…

 //拼接字符串 马丹1,马丹2,马丹3,马丹4,马丹5
         getStringName(list);

List原始数据==>[Student(age=10, name=马丹1, sex=true), Student(age=20, name=马丹2, sex=false), Student(age=10, name=马丹3, sex=true), Student(age=10, name=马丹4, sex=false), Student(age=20, name=马丹5, sex=true)]
优化前：马丹1,马丹2,马丹3,马丹4,马丹5
优化后：马丹1,马丹2,马丹3,马丹4,马丹5

在这里插入图片描述

3. 拼接字符串取年龄 10,15,20,25,30

  //拼接字符串取年龄 10,15,20,25,30
         getAge(list);

List原始数据==>[Student(age=10, name=马丹1, sex=true), Student(age=20, name=马丹2, sex=false), Student(age=10, name=马丹3, sex=true), Student(age=10, name=马丹4, sex=false), Student(age=20, name=马丹5, sex=true)]
可以处理优化前10,20,10,10,20
可以处理优化后10,20,10,10,20

在这里插入图片描述

4.0根据年龄分组 10,10,20,20, …

 //根据年龄分组 10,10,20,20, ....
        ageLimi(list);

List原始数据==>[Student(age=10, name=马丹1, sex=true), Student(age=20, name=马丹2, sex=false), Student(age=10, name=马丹3, sex=true), Student(age=10, name=马丹4, sex=false), Student(age=20, name=马丹5, sex=true)]
可以处理优化前10,20,10,10,20
可以处理优化后10,20,10,10,20

在这里插入图片描述

多层循环嵌套

package com.example.democrud.democurd.Prototype.demo01;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;

import java.util.*;
import java.util.stream.Collectors;

public class ListAndMap1Demo {

    public static void main(String[] args) {

      // 循环中获取数据
    //  stduentgetName();

     //处理异常嵌套数据
          stduents();



    }
    public static void stduentgetName() {

        Map<String, List<Student>> map = stduentInit();
        //System.out.println(JSONObject.toJSON(map));


        for (Map.Entry<String, List<Student>> entry : map.entrySet()) {
            String key = entry.getKey();
            List<Student> list = entry.getValue();
            System.out.println("key===>"+key);
            System.out.println("list===>"+list);

            List<String> collect = list.stream().map(Student::getName).collect(Collectors.toList());
            System.out.println("list： 集合数组==》" + collect);
            String collect1 = list.stream().map(Student::getName).collect(Collectors.joining(","));
            System.out.println("string： String数组==》" + collect1);

            System.out.println("--------------------------------------1---------------------------------------------");
            List<Student> collectle = list.stream().filter(v -> v.getAge() >= 20).collect(Collectors.toList());
            System.out.println("collectle==>"+collectle);



            System.out.println("---------------------------------2--------------------------------------------------");
            List<String> strList = new ArrayList<>();
            for (Student stu : list) {
                strList.add(stu.getName());
            }
            System.out.println("strList: " + strList);

        }


    }

    /**
     * 处理深层嵌套异常数据
     */
    public static void stduents() {

        List<Map<String, String>> list = new ArrayList<>();
        String str = "{\"sheets\":[{\"datas\":[{\"cells\":[{\"dataType\":2,\"value\":\"闫文超\"},{\"dataType\":1,\"value\":\"10.0\"}]},{\"cells\":[{\"dataType\":2,\"value\":\"老王\"},{\"dataType\":1,\"value\":\"20.0\"}]}],\"name\":\"Sheet1\",\"titles\":[\"Name\",\"AGE\"]}]}";
        JSONObject js = JSONObject.parseObject(str);
        //System.out.println(js);
        String sheets = js.get("sheets").toString();
        //System.out.println(sheets);
        JSONArray objects = JSONArray.parseArray(sheets);
        //System.out.println(objects);
        for (Object object : objects) {
            JSONObject js111 = JSONObject.parseObject(object.toString());
            //System.out.println(js111);
            String datas = js111.get("datas").toString();
            //System.out.println(datas);
            JSONArray objects1 = JSONArray.parseArray(datas);
            //System.out.println(objects1);
            for (Object o : objects1) {
                JSONObject js1111 = JSONObject.parseObject(o.toString());
                //System.out.println(js1111);
                String cells = js1111.get("cells").toString();
                //System.out.println(cells);
                JSONArray objects2 = JSONArray.parseArray(cells);
                //System.out.println("objects2 : "+ objects2);
                for (Object o1 : objects2) {
                    JSONObject js11111 = JSONObject.parseObject(o1.toString());
                    //System.out.println(js11111);
                    String dataType = js11111.get("dataType").toString();
                    String value = js11111.get("value").toString();
                    Map<String, String> map = new HashMap<>();
                    map.put(dataType, value);
                    list.add(map);
                    //System.out.println("这他妈那个傻逼写的 dataType=" + dataType + "  value="+ value);
                }

            }
        }

        System.out.println(list);

    }





    /**
     * 初始化list对象
     */
    public static Map<String, List<Student>> stduentInit() {

        Map<String, List<Student>> map = new HashMap<>();
        List<Student> list = new ArrayList<>();
        Student student = new Student(10, "马丹1", true);
        Student student1 = new Student(15, "马丹2", false);
        Student student2 = new Student(20, "马丹3", true);
        Student student3 = new Student(25, "马丹4", false);
        Student student4 = new Student(30, "马丹5", true);
        list.add(student);
        list.add(student1);
        list.add(student2);
        list.add(student3);
        list.add(student4);
        map.put("list", list);

        List<Student> list1 = new ArrayList<>();
        Student stu = new Student(10, "马丹1", true);
        Student stu1 = new Student(15, "马丹2", false);
        Student stu2 = new Student(20, "马丹3", true);
        Student stu3 = new Student(25, "马丹4", false);
        Student stu4 = new Student(30, "马丹5", true);
        list1.add(stu);
        list1.add(stu1);
        list1.add(stu2);
        list1.add(stu3);
        list1.add(stu4);
        map.put("list1", list1);
        return map;
    }


}

1.处理异常嵌套数据

//处理异常嵌套数据
          stduents();

此处不理解的可以把sout注释取下；每步都有打印我这边为了更好的展示就先注释了；

[{2=闫文超}, {1=10.0}, {2=老王}, {1=20.0}]

在这里插入图片描述

2.循环中获取数据

  // 循环中获取数据
        stduentgetName();

key===>list1
list===>[Student(age=10, name=马丹1, sex=true), Student(age=15, name=马丹2, sex=false), Student(age=20, name=马丹3, sex=true), Student(age=25, name=马丹4, sex=false), Student(age=30, name=马丹5, sex=true)]
list： 集合数组==》[马丹1, 马丹2, 马丹3, 马丹4, 马丹5]
string： String数组==》马丹1,马丹2,马丹3,马丹4,马丹5
--------------------------------------1---------------------------------------------
collectle==>[Student(age=20, name=马丹3, sex=true), Student(age=25, name=马丹4, sex=false), Student(age=30, name=马丹5, sex=true)]
---------------------------------2--------------------------------------------------
strList: [马丹1, 马丹2, 马丹3, 马丹4, 马丹5]
key===>list
list===>[Student(age=10, name=马丹1, sex=true), Student(age=15, name=马丹2, sex=false), Student(age=20, name=马丹3, sex=true), Student(age=25, name=马丹4, sex=false), Student(age=30, name=马丹5, sex=true)]
list： 集合数组==》[马丹1, 马丹2, 马丹3, 马丹4, 马丹5]
string： String数组==》马丹1,马丹2,马丹3,马丹4,马丹5
--------------------------------------1---------------------------------------------
collectle==>[Student(age=20, name=马丹3, sex=true), Student(age=25, name=马丹4, sex=false), Student(age=30, name=马丹5, sex=true)]
---------------------------------2--------------------------------------------------
strList: [马丹1, 马丹2, 马丹3, 马丹4, 马丹5]

在这里插入图片描述

wy971744839
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
循环list中的map
qq_34266804的博客
11-20 2583
循环list<Map> java后台list代码： List<Map> aa = new ArrayList<Map>(); Map map = new HashMap(); map.put("1", "痘痘"); aa.add(map); Map map1 = new HashMap(); map1.put("2", "解决"); ...
java多层map嵌套案例
热门推荐
小爷欣欣
03-29 2万+
public Map>>> getItemDefMap() { TmCisDataItemDef tmCisDataItemDef = new TmCisDataItemDef(); List list = tmCisDataItemDefDao.queryForList(tmCisDataItemDef); Map>>> productMap = new HashMap
深入解析Java中List和Map的多层嵌套与拆分
最新发布
沉淀、分享、成长，让自己和他人都能有所收获！
06-02 3万+
作为一个默语博主，我经常收到读者关于如何在Java中处理多层嵌套数据结构的问题。特别是对于List和Map的多层嵌套、拆分和重组，许多开发者感到困惑。在这篇文章中，我们将深入探讨这些问题，提供详细的代码示例，并分享一些实用的技巧，帮助你在这方面取得突破。关键搜索词：Java嵌套List、Java嵌套Map、Java数据结构处理。嵌套数据结构是指一个数据结构内部包含另一个数据结构。例如，一个List中的元素也是List，或者一个Map中的值是另一个Map。
Map循环嵌套对数据分类输出，根据条件进行相应划分
qq_45638369的博客
05-07 547
工作上遇到一个需要将对象集合的json数据按相同条件嵌套输出的问题，现在记录一下。如下列例子中将学生按教室分组，则list中按教室顺序进行分批添加。先添加完教室一再添加教室二，如果穿插添加，那么结果就无法按相同教室进行分组。 废话不多说直接上代码 public class mapTest { public static void main(String[] args) { Map<String,Object> roomMap=null,student........
List,Map多层循环嵌套Demo及其理解
沉淀、分享、成长，让自己和他人都能有所收获！
11-12 5104
希望大家可以通过demo更好的理解他们之间的转换循环与嵌套逻辑；
java实现多层嵌套循环参数转换
06-20
在Java编程中，多层嵌套循环是一种常见的数据处理方式，尤其在处理具有层次关系的数据时，例如构建或解析父子级结构。在这种场景下，我们可能需要遍历多个层级的数据，以便进行转换、操作或者存储到数据库中。下面将...
嵌套Map或者List获取key、value值
04-11
在编程中，尤其是在Java或类似的面向对象语言中，我们经常遇到需要处理复杂数据结构的情况，如嵌套的Map和List。...文件"map、List嵌套的循环检索方法.txt"可能提供了更具体的示例和代码，可以作为进一步学习的参考。
Python减少循环层次和缩进的技巧分析
09-21
虽然这种特性使得Python代码看起来更加整洁，但在处理多层嵌套循环时，缩进过多可能会使代码难以阅读。因此，我们需要寻找策略来减少缩进的层级。 在上述示例中，我们可以看到优化前后的代码对比。优化前的代码使用...
java容器源码-Java-basic-notes-sourcecode:学习Java以来​​的基本入门源代码，包括基本语法，数据类型，分支语
05-19
- if-else语句：学习条件判断和多层嵌套。 - switch-case：了解如何在不同条件下执行不同的代码块。 4. **面向对象思想**： - 封装：理解隐藏内部实现细节，只暴露公共接口的概念。 - 继承：学习如何从一个类...
超级实用的8个Python列表技巧
12-17
对于多层嵌套，可以使用递归或第三方库如`dm-tree`来处理，避免手动处理复杂嵌套。 8. **检查唯一性**： 如果想确保列表中的所有元素都是唯一的，可以利用集合（Set）数据结构，`if len(my_list) == len(set(my_...
java 中list 和map 混合使用。求补集
06-12
使用两个list<Map> 求交集和补集。
List和Map多层嵌套,采用Object简化
qq_45927587的博客
12-20 1075
查询数据库,name去重,数据以集合形式展示
java Map嵌套多个Map
zhouzhiwengang的专栏
05-18 8654
package com.vmware.client; import com.vmware.util.Session; import com.vmware.vim25.DatastoreSummary; import com.vmware.vim25.mo.*; import java.util.HashMap; import java.util.Map; /** * 指定物理服务器所关联的
水果（map循环嵌套）
m0_63925226的博客
01-01 535
每组测试数据的第一行是一个整数M(0
react map 双重循环 嵌套循环
YAOYU007的博客
09-03 1万+
实现效果： 如图，数据是模拟后台输出的json，通过双重循环将数据放到侧边栏中 json数据如下 { "items":[ { "item": "BeJson", "menuItem": ["menu1","menu2","menu3"] }, { "item": "mary", "me
day28 增强for循环进行Map嵌套Map
weixin_34226182的博客
03-22 160
package zuoye; import java.util.HashMap;import java.util.Map.Entry;import java.util.Set; public class zuoye { public static void main(String[] args){ HashMap<Integer,String> a=new HashMap<...
Map系列的遍历方式与Map系列集合及集合的嵌套
z2775640561的博客
11-17 636
如果键存储的是自定义类型的对象，也可以通过重写HashCode和equals方法，也可以保证多个对象内容一样时，LinkedHashMa集合就能认为是重复的。·如果键存储的是自定义类型的对象，可以通过重写HashCode和equals方法，这样可以保证多个对象内容一样时，HashMa集合就能认为是重复的。实际上：原来学的Set系列集合的底层就是基于Map实现的，只是Set集合中的元素只要键数据，不要值数据而已。2.原理：TreeMap跟TreeSet集合的底层原理是一样的，都是基于红黑树实现的排序。
java 循环list map_java List循环与Map循环的总结_java_脚本之家
weixin_39961943的博客
02-19 952
java List循环与Map循环的总结做了一下list和map的总结，没有什么技术含量，就全当复习了一下api。测试环境是在junit4下，如果没有自己写一个main方法也是一样的。首先是List的三种循环:@Testpublic void ForListTest() {List list = new ArrayList();list.add("1");list.add("2");list.a...
使用 map 优化嵌套 for 循环
09-07
使用Map优化嵌套for循环是一种有效的方法，可以简化代码并提高代码的可读性和性能。一般情况下，嵌套for循环的目的是对两个或多个数组进行操作，生成一个新的数组或进行其他计算。 使用Map可以将嵌套for循环转化为单个for循环，使代码更加简洁。下面以一个示例说明： 假设有两个数组arr1和arr2，需要计算它们的乘积并存储在一个新的数组中。 使用嵌套for循环的方式： ```python arr1 = [1, 2, 3] arr2 = [4, 5, 6] result = [] for i in arr1: for j in arr2: result.append(i * j) print(result) ``` 使用Map优化的方式： ```python arr1 = [1, 2, 3] arr2 = [4, 5, 6] result = list(map(lambda x, y: x * y, arr1, arr2)) print(result) ``` 在使用Map的方式中，我们通过使用lambda函数定义一个简单的乘法操作来替代内层的for循环。这样一来，我们只需要使用一个单独的map函数来对两个数组进行操作，并生成一个新的数组。 使用Map优化嵌套for循环的好处是简化了代码结构，避免了多层嵌套的for循环，使代码更加易读。同时，它还可以提高代码的性能，因为map函数是一种高级函数，使用C级别的优化来执行操作，比嵌套for循环更有效率。 总之，使用Map优化嵌套for循环是一种提高代码效率和可读性的好方法，特别适用于对多个数组进行操作的情况。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

wy971744839

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值