精华内容
下载资源
问答
  • java双重for循环优化
    2022-06-06 20:08:07

    双重for循环优化:是将某一层的数据转成map类型,用比较字段去map里面get,若拿到数据则匹配上了

    import lombok.Data;
    
    
    
    @Data
    public class Wupin {
        private  String orderId;
    
        private  String wupingName;
    
    }
    
    import lombok.Data;
    
    @Data
    public class Order {
    
        private String userName;
    
        private String orderId;
    
        private String wupingName;
    }
    
    package com.ruoyi.qc.dto;
    
    import cn.hutool.json.JSONUtil;
    import lombok.val;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.stream.Collectors;
    
    public class TestMain {
    
        public static void main(String[] args) throws InterruptedException {
            List<Order> orderList = new ArrayList<>();
            for (int i = 0; i < 10000; i++) {
                Order order = new Order();
                order.setOrderId("orderid_"+i);
                order.setUserName("用户名称"+i);
                orderList.add(order);
            }
    
            List<Wupin> wupinList = new ArrayList<>();
            for (int i = 10000; i >0; i--) {
                Wupin Wupin = new Wupin();
                Wupin.setOrderId("orderid_"+i);
                Wupin.setWupingName("物品_"+i);
                wupinList.add(Wupin);
            }
            traditionFor(wupinList,orderList);
        }
    
        /**
         * 传统双重for循环
         * */
        public static void traditionFor(List<Wupin> wupinList, List<Order> orderList) throws InterruptedException {
            System.out.println("传统双重for循环");
            int count = 0;
            Long startTime =System.currentTimeMillis();
            System.out.println("当前时间:"+startTime);
            for (Order order:orderList) {
                for (Wupin wupin:wupinList) {
                    count++;
                    Thread.sleep(1);
                    if (wupin.getOrderId().equals(order.getOrderId())){
                        order.setWupingName(wupin.getWupingName());
                    }
                }
            }
            Long endTime =System.currentTimeMillis();
            System.out.println("结束时间:"+endTime);
            System.out.println("循环次数:"+count);
    
        }
    
    
        /**
         * 优化双重for循环
         * */
        public static void traditionFor2(List<Wupin> wupinList, List<Order> orderList) throws InterruptedException {
            int count = 0;
            Long startTime =System.currentTimeMillis();
            System.out.println("当前时间:"+startTime);
            //集合转map
           val s=  wupinList.stream().collect(Collectors.toMap(Wupin::getOrderId, Wupin->Wupin));
            for (Order order:orderList) {
                val wuping = s.get(order.getOrderId());
                Thread.sleep(1);
                if (wuping != null){
                    order.setWupingName(wuping.getWupingName());
                    count++;
                }
            }
            Long endTime =System.currentTimeMillis();
            System.out.println("结束时间:"+endTime);
            System.out.println("循环次数:"+count);
            System.out.println(JSONUtil.toJsonStr(orderList));
        }
    }
    

    更多相关内容
  • 主要介绍了Java for循环性能优化实现解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • java 优化双重for循环

    千次阅读 2022-04-07 13:40:43
    首先我们要有两个对象分别是 学生信息 和 学生住宿信息 class Student { //学生id private Integer studentUserId; //学生名称 private String name; } class Student { //学生id ... pri

    首先我们要有两个对象分别是 学生信息 和 学生住宿信息

        class Student {
            //学生id
            private Integer studentUserId;
    
            //学生名称
            private String name;
    
        }
    
        class studentRooms {
            //学生id
            private Integer studentUserId;
    
            //学生名称
            private String roomInfo;
    
        }
    

    将对象填充参数

            //学生信息
            List<Student> students = new ArrayList<>();
            students.add(Student.builder().studentUserId(111).name("张三").build());
            students.add(Student.builder().studentUserId(222).name("李四").build());
    
            //学生住宿信息
            List<StudentRoom> studentRooms = new ArrayList<>();
            studentRooms.add(StudentRoom.builder().studentUserId(222).roomInfo("住宿").build());
            studentRooms.add(StudentRoom.builder().studentUserId(111).roomInfo("走读").build());
    

    这时我们的需求是, 将两边集合数据中, 相同studentUserId 数据拼接到一起返回给前端 如:

    {
    	"studentUserId":111,
    	"name":"张三",
    	"roomInfo":"走读"
    }
    

    这时候我们常规的写法就是 遍历两个集合 判断studentUserId 如果相同则拼装数据

    for (Student student : students) {
        for (StudentRoom studentRoom : studentRooms) {
             //判断学生id是否相同
             if (student.getStudentUserId().equals(studentRoom.getStudentUserId())) {
                System.out.println("拼装数据返回给前端");
             }
         }
    }
    

    上述这种写法面临最大的问题就是时间复杂度为O(n^2)对 n 个数进行排序,需要扫描 n X n 次
    对于上述代码也就是 2 x 2 = 4次

    那么如何优化这种情况呢? 这里我们可以采用JDK1.8新特性的 stream流做处理代码如下

          //根据学生Id转成Map
          Map<Integer, StudentRoom> studentRoomByUserId = studentRooms.stream().collect(Collectors.toMap(StudentRoom::getStudentUserId, Function.identity()));
          for (Student student : students) {
                //根据外层遍历的学信息id get学生住宿信息Map中的Key
                StudentRoom studentRoom = studentRoomByUserId.get(student.getStudentUserId());
                //如果能get到数据!=null 说明id一样
                if (studentRoom != null) {
                    System.out.println("拼装数据返回给前端");
                }
            }
    

    按照上述这种操作方法会大大减少时间复杂度为O(n), 而循环的次数也变为了2次
    完整代码

    public class Test{
    
        @Data
        @Builder
        class Student {
            //学生id
            private Integer studentUserId;
    
            //学生名称
            private String name;
    
        }
    
        @Data
        @Builder
        class StudentRoom {
            //学生id
            private Integer studentUserId;
    
            //学生住宿信息
            private String roomInfo;
        }
    
        public void test() {
    
            //学生信息
            List<Student> students = new ArrayList<>();
            students.add(Student.builder().studentUserId(111).name("张三").build());
            students.add(Student.builder().studentUserId(222).name("李四").build());
    
            //学生住宿信息
            List<StudentRoom> studentRooms = new ArrayList<>();
            studentRooms.add(StudentRoom.builder().studentUserId(222).roomInfo("住宿").build());
            studentRooms.add(StudentRoom.builder().studentUserId(111).roomInfo("走读").build());
    
            //根据学生Id转成Map
            Map<Integer, StudentRoom> studentRoomByUserId = studentRooms.stream().collect(Collectors.toMap(StudentRoom::getStudentUserId, Function.identity()));
            
            for (Student student : students) {
                //根据外层遍历的学信息id get学生住宿信息Map中的Key
                StudentRoom studentRoom = studentRoomByUserId.get(student.getStudentUserId());
                //如果能get到数据说明id一样
                if (studentRoom != null) {
                    System.out.println("拼装数据返回给前端");
                }
            }
        }
    
    
        //学生信息List
    
    }
    
    展开全文
  • java 解决双重for循环效率问题

    千次阅读 2021-07-20 13:23:50
    解决双重for循环效率问题题目说明题解 题目说明 当拥有2个表时,订单表和物品表 时,订单表(客户名称,订单ID)和物品表(订单ID,物品名称)一个客户可以购买多个物品,但是他们的订单ID是唯一的,数据库中数据以...

    解决双重for循环效率问题

    题目说明

    当拥有2个表时,订单表物品表 时,订单表(客户名称,订单ID)和物品表(订单ID,物品名称)一个客户可以购买多个物品,但是他们的订单ID是唯一的,数据库中数据以JSON字符串的形式传给你。

    订单表

    订单ID客户名称
    A1
    B2
    C3

    物品表

    订单ID物品名称
    A1
    B2
    C3

    请输出购买最多商品的人?购买最少商品的人?和平均一个人购买多少商品。

    题解

    1.解决思路,使用映射关系,提取出关键信息进行两表关联。
    客户名称 ↔ 订单ID
    订单ID ↔ 物品名称
    2.使得 订单ID作为唯一性属性进行映射对应。
    3.使用Map集合类型代替双重循环提高效率

    	/**
    	* 提供String orderJSON = “”; 存放订单JSON
    	* 提供String commodityJSON = “”; 存放商品JSON
    	*/
    	Map<String,String> orderMap = new HashMap();
    	Map<String,Integer> commodity = new HashMap();
    
    	JSONArray orderJsonArray = JSON.parseArray(orderJSON);
    	for(int i = 0;i<orderJsonArray .size();i++){
    		String orderStr = orderJsonArray.getString(i);
    		JSONObject jsonObject = JSONArray.parseObject(orderStr);
    		String customerName = jsonObject.getString("CustomerName");
    		String orderID = jsonObject.getString("OrderID");
    		orderMap.put(customerName,orderID);
    	}
    
    	JSONArray commodityJsonArray = JSON.parseArray(commodityJSON);
    	for(int i = 0;i<commodityJsonArray .size();i++){
    		String commodityStr = commodityJsonArray.getString(i);
    		JSONObject jsonObject = JSONArryay.parseObject(commodityStr);
    		String orderID = jsonObject.getString("OrderID");
    		String commodityName = jsonObject.getString("CommodityName");
    		if(commodity.get(orderID)==null){
    			commodity.put(orderID,1);
    		}else{
    			commodity.put(orderID,commodity.get(orderID)+1);
    		}
    	}
    
    	String maxStr = "";
    	String minStr = "";
    	int sum = 0;
    	int max = 0;
    	int min = commodity.size()/orderMap.size();
    	Iterator<Map.Entry<String, Integer>> iterator = commodity.entrySet().iterator();
    	while (iterator.hasNext()) {
    		Map.Entry<String, Integer> entry = iterator.next();
    		//System.out.println(entry.getKey() + "  " + entry.getValue());
    		sum += entry.getValue();
    		if(entry.getValue()>max()){
    			max = entry.getValue();
    			maxStr = orderMap.get(entry.getKey());
    		}
    		if(entry.getValue()<=min()){
    			min = entry.getValue();
    			minStr = orderMap.get(entry.getKey());
    		}
    	}
    	System.out.println("平均一个用户买物品数为 : "+sum/commodity.size());
    	System.out.println("购买最多的客户是 : "+maxStr+" 购买数量为:"+max);
    	System.out.println("购买最少的客户是 : "+minStr+" 购买数量为:"+min);
    	
    
    展开全文
  • 双重for循环优化

    千次阅读 2020-12-28 10:18:30
    双重for循环优化 双重for循环优化思想:主要是将某一层的数据转成map类型,用比较字段去map里面get,若拿到数据则匹配上了 由于是在云上开发,代码拿不下来(公司限制了),就只能截图了,希望读者将就着看。 ...

    双重for循环优化

    双重for循环优化思想:主要是将某一层的数据转成map类型,用比较字段去map里面get,若拿到数据则匹配上了

    由于是在云上开发,代码拿不下来(公司限制了),就只能截图了,希望读者将就着看。

     

    展开全文
  • 双重for循环优化方案
  • Java优化for循环嵌套的高效率方法

    千次阅读 2021-02-28 19:16:31
    前几天有人问过我一个问题,就是两个嵌套for循环执行效率的问题,问有什么好的办法替换。当时我想了想,实在想不起来,哎,惭愧!!! 请教了答案,恍然大悟。比如:两个list中分别装有相同的对象数据。 list1中有3...
  • 双重for循环遍历优化

    千次阅读 2020-07-16 17:12:12
    下面展示3中遍历循环方式耗时比较 public static void main(String[] args) { /* 用户信息集合 */ List<UserInfo> userInfoList = new ArrayList<>(); /* 订单信息集合 */ List<OrderInfo> ...
  • 首先先来一个案例简单模拟一下:List wifes = new ArrayList();...for(int i=0;i<8000;i++){wifes.add(new Wife(i, i+"的妻子", "000"+i));}for(int i=0;i<8000;i++){husbands.add(new Husband(i, "...
  • java stream 实现双重for循环

    千次阅读 2021-08-15 10:31:32
    给定列表[1, 2, 3]和列表[3, 4]...import java.util.*; import java.util.stream.Collectors; public class Main { public static void main(String[] args) { List<Integer> numbers1 = Arrays.asList(1, 2
  • 双重for循环3.list结合map总结 前言 今天群友问了一个问题,多重for循环怎么优化? 然后有感而发,将平时编码中对于该种问题的解决方法分享出来,欢迎大家一起探讨学习! 一、优化方案 通过list结合map的方式降低...
  • 双重for循环优化

    千次阅读 2020-05-20 18:06:51
    demo如下: public class TestM { public static void main(String[] ... for (int i = 0; i <15 ; i++) { aaa();//630 //bbb();//600 } } private static void aaa() { long s = System.currentTime.
  • 主要介绍了Java8处理List的双层循环问题,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • javafor循环性能的优化(一)

    千次阅读 2018-02-16 21:21:07
    for 循环性能测试(多层for循环的嵌套顺序)由于CPU在内外之间的切换会有一定的开销,因此如果可能的话, 应该尽可能较少内外层循环切换的次数.只需使最外层循环的次数最少,内层循环次数多即可. (若观点有误请大神们...
  • 增强for循环的使用(遍历集合和数组)
  • Java 双重for循环性能

    千次阅读 2017-02-28 17:01:26
    血的教训:尽量不要在循环内部对单条数据做处理,这会导致程序非常慢,如: Java code for (Map map : dataList2) {  String[] valArr = new String[fields.length];    for (int i = 0; i  String fieldType ...
  • 比如:两个list中分别装有相同的对象数据,firstList中有6万条对象数据,secondList中有3万条对象数据(但是对象中的name属性变量为空)。...先 for循环 secondList,判断一下每个对象的name属性变量是否为空,如果为...
  • 我们的目的是优化代码性能,但是有自己适用场景,一般list内存的都是每条对象,对象都会有唯一标识,比如id 第一步,将List转化为Map 下面的方法将List<Map<String, Object>>(Map中具有唯一的id标识)
  • for循环优化 --- 多线程并发实现

    千次阅读 2022-01-29 09:21:35
    而当for循环的次数过多,以及多重for循环时,我们会发现执行效率会变的很低,整体耗时非常多。 本次我们就使用多线程并发的方式来对循环进行优化。 多线程并发实现 1. 创建线程池 // newFixedThreadPool是...
  • 多重for循环优化,提升运行效率

    万次阅读 多人点赞 2018-07-18 09:37:08
    在循环次数较少的时候一般...客户体验会非常不好,才研究这个情况的,事实证明,优化后的多重for循环提升了一大半的效率,是不是很神奇。 当然,本文也有借鉴其他同胞的方法。 实例化变量放在for循环外,减少实...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,150
精华内容 3,260
关键字:

java双重for循环优化