精华内容
下载资源
问答
  • 测试10w条数据双层for循环耗时 import java.util.ArrayList; import java.util.List; /** * @author 954L * @create 2019/12/31 20:42 */ public class Main { public static void main(String[] args) {...

     

    业务场景中很经常类似的需求,对两个List相同的数据进行处理。例子如下:

    import lombok.Builder;
    import lombok.Data;
    import lombok.experimental.Tolerate;
    
    /**
     * @author 954L
     * @create 2019/12/31 20:42
     */
    @Data
    @Builder
    public class User {
    
        private String name;
    
        @Tolerate
        public User(){}
    
    }
    import java.util.Arrays;
    import java.util.List;
    
    /**
     * @author 954L
     * @create 2019/12/31 20:42
     */
    public class Main {
    
        public static void main(String[] args) {
            User zs = User.builder().name("张三").build();
            User ls = User.builder().name("李四").build();
            List<User> list1 = Arrays.asList(zs);
            List<User> list2 = Arrays.asList(ls);
            for (User user1: list1){
                for (User user2 : list2){
                    if (user1.getName().equals(user2.getName())){
                        //TODO 执行业务逻辑
                        break;
                    }
                }
            }
        }
    }

    假设大数据量情况下上述执行代码list2则会出现很多不必要的循环,直到equals为止,假设使用map,直接getKey出相同的list2中的对象,则效率可以大大提升!

     

    测试10w条数据双层for循环耗时

    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * @author 954L
     * @create 2019/12/31 20:42
     */
    public class Main {
    
        public static void main(String[] args) {
            List<User> list1 = new ArrayList<>();
            for (int i = 0; i <= 100000; i++){
                list1.add(User.builder().name("张三" + i).build());
            }
            List<User> list2 = new ArrayList<>(list1);
            long startTime = System.currentTimeMillis();
            for (User user1: list1){
                for (User user2 : list2){
                    if (user1.getName().equals(user2.getName())){
                        //TODO 执行业务逻辑
                        break;
                    }
                }
            }
            System.out.println(System.currentTimeMillis() - startTime);
        }
    }

     

    测试HashMap耗时时间

    import java.util.ArrayList;
    import java.util.List;
    import java.util.Map;
    import java.util.function.Function;
    import java.util.stream.Collectors;
    
    /**
     * @author 954L
     * @create 2019/12/31 20:42
     */
    public class Main {
    
        public static void main(String[] args) {
            List<User> list1 = new ArrayList<>();
            for (int i = 0; i <= 100000; i++){
                list1.add(User.builder().name("张三" + i).build());
            }
            List<User> list2 = new ArrayList<>(list1);
            Map<String, User> list2Map = list2.stream()
                    .collect(Collectors.toMap(User::getName, Function.identity()));
            long startTime = System.currentTimeMillis();
            for (User user1: list1){
                User user = list2Map.get(user1.getName());
                if (user != null){
                    //TODO 执行业务逻辑
                }
            }
            System.out.println(System.currentTimeMillis() - startTime);
        }
    }

     

    测试结果一目了然了。

    but!数据量小的时候还是建议用list,差别不大。毕竟相同大小map占用的内存空间比list大

     

     

    对你有帮助的话,右上角给个赞呗~

     

     

     

     

     

     

    展开全文
  • 首先先来一个案例简单模拟一下: Listwifes = new ArrayList(); Listhusbands= new ArrayList(); for(int i=0;i;i++){ wifes.add(new Wife(i, i+"的妻子", "000"+i)); } for(int i=0;... 这种效率天差地别。

    首先先来一个案例简单模拟一下:

    Listwifes = new ArrayList();

    Listhusbands= 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, "我是"+i, "000"+i));

    }

    //现在需要让妻子和丈夫进行配对组成一个家庭,按照familyId进行配对

    在1.8之前你会这么写:

    for(int i=0;i

    如果按照jdk1.8的lamada表达式进行匹配的话。这个测试结果是ms级别的

    // 将list转为Map,这里key一定要为唯一值,map(familyId,wife对象)

    MapwifeMap = wife.stream().collect(

    Collectors.toMap(w -> w.getFamilyId(),

    w -> w));

    // 匹配家庭

    families = husband.stream().map(h -> {

    //从wifeMap里面根据husband的familyId去匹配。匹配上后组装成家庭对象然后放入集合。最后生成新的家庭集合

    return toFamily(wifeMap.get(h.getFamilyId()), h);

    }).collect(Collectors.toList());

    这是个测试案例:亲测如下:

    package com.nuanshui.frms.report.manage;

    import com.google.common.collect.Lists;

    import org.junit.Test;

    import java.math.BigDecimal;

    import java.util.List;

    import java.util.Map;

    import java.util.stream.Collectors;

    /**

    * Author:

    * Date: 2016/11/23.

    * Time: 18:17

    */

    public class TestFamily {

    @Test

    public void familyTest() {

    Listwife = Lists.newArrayList();

    Listhusband = Lists.newArrayList();

    for(int i=0;i<8000;i++){

    wife.add(new Wife(i, i+"的妻子", "000"+i));

    }

    for(int i=0;i<8000;i++){

    husband.add(new Husband(i, "我是"+i, "000"+i));

    }

    Long startTime =System.currentTimeMillis();

    System.out.println("当前时间:"+startTime);

    Listfamilies = Lists.newArrayList();

    // 将list转为Map,这里key一定要为唯一值

    MapwifeMap = wife.stream().collect(

    Collectors.toMap(w -> w.getFamilyId(),

    w -> w));

    // 匹配家庭

    families = husband.stream().map(h -> {

    return toFamily(wifeMap.get(h.getFamilyId()), h);

    }).collect(Collectors.toList());

    /*for(int i=0;i{

    System.out.println("家庭ID:" + family.getFamilyId() + ",丈夫:" + family.getHusbandName() + ",妻子:" + family.getWifeName());

    });

    Long endTime =System.currentTimeMillis();

    System.out.println("结束时间:"+endTime);

    System.out.println("------------耗时:---------"+(endTime-startTime)+"ms");

    }

    private Family toFamily(Wife wife, Husband husband) {

    Family family = new Family();

    family.setFamilyId(wife.getFamilyId());

    family.setHusbandName(husband.getHusbandName());

    family.setWifeName(wife.getWifeName());

    return family;

    }

    @Test

    public void test1(){

    //String.valueOf()

    BigDecimal c = new BigDecimal(651000);

    BigDecimal d = new BigDecimal(312);

    BigDecimal num3 = c.divide(d,10,BigDecimal.ROUND_HALF_DOWN);

    System.out.println(num3);

    BigDecimal b = (new BigDecimal(651000).divide(new BigDecimal(312)).setScale(1, BigDecimal.ROUND_HALF_UP));

    System.out.println(b);

    }

    }

    结果只要252ms;

    这种效率天差地别。

    展开全文
  • [img=https://img-bbs.csdn.net/upload/201309/23/1379926743_886766.jpg][/img] [size=16px][color=#FF0000]本人的测试结果[/color][/size] [img=... 望能探讨一二
  • 首先先来一个案例简单模拟一下: List<String> wifes = new ArrayList(); List<String> husbands= new ArrayList(); for(int i=0;... wifes.add(new Wife(i, i+"的妻子", "000"+i));...这种效率天差地别。  

    首先先来一个案例简单模拟一下:

    List<String> wifes = new ArrayList<String>();
    List<String> husbands= new ArrayList<String>();
    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, "我是"+i, "000"+i));
    }
    
    //现在需要让妻子和丈夫进行配对组成一个家庭,按照familyId进行配对
    在1.8之前你会这么写:
    for(int i=0;i<wifes.size();i++){
            System.out.println("i:"+i);
        for(int j=0;j<husbands.size();j++){
            System.out.println("j:"+j);
              if(妻子的familyid==丈夫的familyid){
                    System.out.println("匹配成功:"+i+":"+j);
              }
        }
    }
    已8000*8000的两个集合进行配对。那就要循环8000*8000次。按20s循环一轮。需要20*8000秒

    如果按照jdk1.8的lamada表达式进行匹配的话。这个测试结果是ms级别的

    // 将list转为Map,这里key一定要为唯一值,map(familyId,wife对象)
    Map<String, Wife> wifeMap = wife.stream().collect(
            Collectors.toMap(w -> w.getFamilyId(),
                    w -> w));
    // 匹配家庭
    families = husband.stream().map(h -> {
        //从wifeMap里面根据husband的familyId去匹配。匹配上后组装成家庭对象然后放入集合。最后生成新的家庭集合
        return toFamily(wifeMap.get(h.getFamilyId()), h);
    }).collect(Collectors.toList());

    这是个测试案例:亲测如下:

    package com.nuanshui.frms.report.manage;
    
    
    import com.google.common.collect.Lists;
    import org.junit.Test;
    
    import java.math.BigDecimal;
    import java.util.List;
    import java.util.Map;
    import java.util.stream.Collectors;
    
    /**
     * Author:
     * Date: 2016/11/23.
     * Time: 18:17
     */
    public class TestFamily {
        @Test
        public void familyTest() {
            List<Wife> wife = Lists.newArrayList();
            List<Husband> husband = Lists.newArrayList();
            for(int i=0;i<8000;i++){
                wife.add(new Wife(i, i+"的妻子", "000"+i));
            }
    
            for(int i=0;i<8000;i++){
                husband.add(new Husband(i, "我是"+i, "000"+i));
            }
            Long startTime =System.currentTimeMillis();
            System.out.println("当前时间:"+startTime);
            List<Family> families = Lists.newArrayList();
            // 将list转为Map,这里key一定要为唯一值
            Map<String, Wife> wifeMap = wife.stream().collect(
                    Collectors.toMap(w -> w.getFamilyId(),
                            w -> w));
            // 匹配家庭
            families = husband.stream().map(h -> {
                return toFamily(wifeMap.get(h.getFamilyId()), h);
            }).collect(Collectors.toList());
            /*for(int i=0;i<wife.size();i++){
                System.out.println("i:"+i);
                for(int j=0;j<husband.size();j++){
                    System.out.println("j:"+j);
                    if(wife.get(i).getFamilyId().equals(husband.get(j).getFamilyId())){
                        System.out.println("匹配成功:"+i+":"+j);
                    }
                }
            }*/
            System.out.println("循环完成");
            families.stream().forEach(family -> {
                System.out.println("家庭ID:" + family.getFamilyId() + ",丈夫:" + family.getHusbandName() + ",妻子:" + family.getWifeName());
            });
            Long endTime =System.currentTimeMillis();
            System.out.println("结束时间:"+endTime);
            System.out.println("------------耗时:---------"+(endTime-startTime)+"ms");
        }
    
        private Family toFamily(Wife wife, Husband husband) {
            Family family = new Family();
            family.setFamilyId(wife.getFamilyId());
            family.setHusbandName(husband.getHusbandName());
            family.setWifeName(wife.getWifeName());
            return family;
        }
    
        @Test
        public void test1(){
            //String.valueOf()
            BigDecimal c = new BigDecimal(651000);
            BigDecimal d = new BigDecimal(312);
            BigDecimal num3 = c.divide(d,10,BigDecimal.ROUND_HALF_DOWN);
            System.out.println(num3);
            BigDecimal b = (new BigDecimal(651000).divide(new BigDecimal(312)).setScale(1, BigDecimal.ROUND_HALF_UP));
            System.out.println(b);
    
        }
    }
    
    

    结果只要252ms;

    这种效率天差地别。

     

    展开全文
  • 首先先来一个案例简单模拟一下: List wifes = new ArrayList(); List husbands= new ArrayList(); for(int i=0;i;i++){ wifes.add(new Wife(i, i+"的妻子", "000"+i)); } for(int i=0;... 这种效率天差地别。

    首先先来一个案例简单模拟一下:

    List wifes = new ArrayList();

    List husbands= 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, "我是"+i, "000"+i));

    }

    //现在需要让妻子和丈夫进行配对组成一个家庭,按照familyId进行配对

    在1.8之前你会这么写:

    for(int i=0;i

    System.out.println("i:"+i);

    for(int j=0;j

    System.out.println("j:"+j);

    if(妻子的familyid==丈夫的familyid){

    System.out.println("匹配成功:"+i+":"+j);

    }

    }

    }

    已8000*8000的两个集合进行配对。那就要循环8000*8000次。按20s循环一轮。需要20*8000秒

    如果按照jdk1.8的lamada表达式进行匹配的话。这个测试结果是ms级别的

    // 将list转为Map,这里key一定要为唯一值,map(familyId,wife对象)

    Map wifeMap = wife.stream().collect(

    Collectors.toMap(w -> w.getFamilyId(),

    w -> w));

    // 匹配家庭

    families = husband.stream().map(h -> {

    //从wifeMap里面根据husband的familyId去匹配。匹配上后组装成家庭对象然后放入集合。最后生成新的家庭集合

    return toFamily(wifeMap.get(h.getFamilyId()), h);

    }).collect(Collectors.toList());

    这是个测试案例:亲测如下:

    package com.nuanshui.frms.report.manage;

    import com.google.common.collect.Lists;

    import org.junit.Test;

    import java.math.BigDecimal;

    import java.util.List;

    import java.util.Map;

    import java.util.stream.Collectors;

    /**

    * Author:

    * Date: 2016/11/23.

    * Time: 18:17

    */

    public class TestFamily {

    @Test

    public void familyTest() {

    List wife = Lists.newArrayList();

    List husband = Lists.newArrayList();

    for(int i=0;i<8000;i++){

    wife.add(new Wife(i, i+"的妻子", "000"+i));

    }

    for(int i=0;i<8000;i++){

    husband.add(new Husband(i, "我是"+i, "000"+i));

    }

    Long startTime =System.currentTimeMillis();

    System.out.println("当前时间:"+startTime);

    List families = Lists.newArrayList();

    // 将list转为Map,这里key一定要为唯一值

    Map wifeMap = wife.stream().collect(

    Collectors.toMap(w -> w.getFamilyId(),

    w -> w));

    // 匹配家庭

    families = husband.stream().map(h -> {

    return toFamily(wifeMap.get(h.getFamilyId()), h);

    }).collect(Collectors.toList());

    /*for(int i=0;i

    System.out.println("i:"+i);

    for(int j=0;j

    System.out.println("j:"+j);

    if(wife.get(i).getFamilyId().equals(husband.get(j).getFamilyId())){

    System.out.println("匹配成功:"+i+":"+j);

    }

    }

    }*/

    System.out.println("循环完成");

    families.stream().forEach(family -> {

    System.out.println("家庭ID:" + family.getFamilyId() + ",丈夫:" + family.getHusbandName() + ",妻子:" + family.getWifeName());

    });

    Long endTime =System.currentTimeMillis();

    System.out.println("结束时间:"+endTime);

    System.out.println("------------耗时:---------"+(endTime-startTime)+"ms");

    }

    private Family toFamily(Wife wife, Husband husband) {

    Family family = new Family();

    family.setFamilyId(wife.getFamilyId());

    family.setHusbandName(husband.getHusbandName());

    family.setWifeName(wife.getWifeName());

    return family;

    }

    @Test

    public void test1(){

    //String.valueOf()

    BigDecimal c = new BigDecimal(651000);

    BigDecimal d = new BigDecimal(312);

    BigDecimal num3 = c.divide(d,10,BigDecimal.ROUND_HALF_DOWN);

    System.out.println(num3);

    BigDecimal b = (new BigDecimal(651000).divide(new BigDecimal(312)).setScale(1, BigDecimal.ROUND_HALF_UP));

    System.out.println(b);

    }

    }

    结果只要252ms;

    这种效率天差地别。

    展开全文
  • 充分利用循环可以提高程序的开发和执行效率,但是如果不注重循环中的算法很容易导致程序的死循环,那将是程序的死穴。所以在循环体中要对可能出现的特殊情况使用break语句中断循环。 public class BreakCyc { ...
  • 有两张表A、B。 A有500条记录,B有500乃至更多条,查询A表所有记录封装成List; 现根据A表的ID查询B表中对应的记录,那么 List<A> listA = getObjects(A.class);... for(A a : listA){/*...这两种方式哪个效率
  • 关于执行两个for循环效率注意点

    千次阅读 2012-10-23 14:18:31
    问题: for(i=0;i for(j=0;j {} for(j=0;...这两个程序哪个执行效率高?...效率高 ...双层循环,较长的循环放在内层效率要高 for(j=0;j for(i=0;i {} 这样内层循环要构造100次,所以频繁的在循
  • 冒泡排序(Bubble Sort)是常用的数组排序算法之一,它以简洁的思想与实现方法而备受青睐,也是广大学习者最先接触的一种排序算法。...冒泡排序的算法比较简单,排序的结果稳定,但时间效率不太高。Ja...
  • 算法的执行效率,粗略地讲,就是算法代码执行的时间.这里有段非常简单的代码,求1,2,3…n的累加和。现在,我就带你一块来估算一下这段代码的执行时间。 int cal(int n) { int sum = 0; int i = 1; for (; i <= n;...
  • 补充一:关于某个双层循环提高效率的场景: 有2个集合:   List list = new ArrayList(); List list2 = new ArrayList(); for(int i=0; i; i++) { list.add(i); } for(int i=0; i; i+=2) { ...
  • javascript 数组去重

    2018-12-01 22:37:00
    总结:使用ES6的Set和Map效率最高,reduce()和sort()效率还可以,双层循环效率最低。 第一种:ES6方法 function uniqueArray(arr) { return Array.from(new Set(arr)) } function uniqueArray(arr) { const...
  • 循环语句(for)

    2016-11-16 20:52:47
    三要素:起始条件 终止条件 变化条件理解双层循环对于二维的意义 1.for (开始条件;终止条件;变化条件) 2.两层的for循环意味着 二维 的概念,它循环次数是外层 * 内层的次数,可以用来制作 表格,注意 循环的...
  • for执行效率

    2015-04-11 18:30:00
    1. for(i=0;i<5;i++) for(j=0;j<100;j++)2....j<100;j++) for(i=0;...* 双层循环,较长的循环放在内层效率要高 特例:intx[1000][100];for(i=0;i<1000;i++) for(j=0;j<100;j++) { //access...
  • 问题: 福彩双色球 红色球 :6个 从1-33中选出6个不能重复的数。 蓝色球:1个,从1-16中...第一种思路是每次生成一个数遍历数组中之前生成的数,这样写时间复杂度为O(n*n),双层循环效率低。 第二种思路为先定义一个
  • 很多时候搜索可以和排序结合起来使用以提高... 一般的暴力解法直接用双层循环一个元素一个元素比较,复杂度为n平方  可以先排序再判断,排序复杂度为nlogn,再进行比较,如何比较  A : 2 4 5 7  B : 1 2 3 ...
  • 为解决车间物料配送费用高、配送效率低、灵活性差等问题, 建立了基于bi-level双层规划的车间物料循环配送模型。针对模型设计了基于2-opt改进的最大最小蚁群算法和双层迭代算法, 引入线旁库存的限制, 求得需求点的...
  • 我们设置一个两个类A、B,A的数据成员中包含一个B的对象,然后我们使用双层循环来实验,多层对象引用方式和直接对象引用方式的效率。代码例子: public class AboutDuoJiQianTaoYinYong { public sta
  • 参评的几款模板引擎为:XMLTemplate(简称XT)Velocity(简称VT)CommonTemplate(简称CT)FreeMarker(简称FT)Smarty4j(简称ST)直接的java代码...测试方法为双层循环,输出的中间体是一个空的不执行任何操作的Writer类,尽...
  • 记得才出来工作时,被一家银行面试技术,问的几乎都是算法上的问题,其中有一道直指 双层 for 循环,是大的先遍历还是小的先遍历?然而,当时想到的是 “ 缓存Cache和内存块的度取效率” ,于是乎就有了这样的答案 ...
  • **:运用双层循环,判断是否为质数,true则num+1;false跳过 代码如下: package somethings; import java.util.Locale; /** * @author Small_Tsky * @date 2020/2/23 - 16:21 **/ public class Unimportance.....
  • 数组去重方法在不同浏览器下效率

    千次阅读 2013-11-15 00:00:51
    想想那最简单的,申请一个新的数组,双层for循环排序,现在真想对自己说,你是个猪脑子啊,除了最笨最差的,你还能想到其他的不? 现在就来分析下,为啥那个之前给的排序有这么差吧。 首先给出我一直以来的最差...
  • 在子查询返回数据比较少时,尽量使用in,exists相当于一个双层循环,需要测试,已确定具体哪一种效率更高 3 or有时效率非常低,某些情况下可以替换为in提高查询效率。 4尽量减少查询次数,某些情况下通过in来合并...
  • 排序

    2020-08-06 08:59:13
    已经有序,双层循环变为单层,O(n) O(n2 ) 稳定 希尔排序 O(1) 无 O(n2) 不稳定 冒泡排序 O(n) 已经有序,O(n) O(n2) 稳定 快速排序 O(log2n) 越无序效率越高,O(log2n) O(n2) 不稳定 简单选择排序 O(1) O...
  • 文章目录利用双层for循环去重 一利用双层for循环去重 二利用indexOf()去重利用对象类型实现去重利用Set对象实现去重利用reduce()实现去重 利用双层for循环去重 一 最简单的思路,但去重效率低。 思路:外层循环的...
  • 从最基础的双层n循环到开方循环再到筛法,效率不断提高,这里我们便省略最基础的两种双层循环的方法,直接从筛法说起。 埃氏筛法 埃氏筛法的主要思想为,大于1的任意数n的倍数m都不是素数,因为m必然可以被n整除。 ...
  • 1、暴力法,双层for循环效率巨低,打败14% 2、双指针,单次循环,头尾相比,利用是一个升序数组,每次判断如果小于目标值呢,head++,大于目标值呢tail–,打败95% 题解 class Solution { /*暴力双层for循环 ...
  • 选择排序SelectionSort

    2018-04-16 17:41:58
    核心思想也是进行双层循环,但是内层循环有保存最小值的临时变量默认为上层循环的值,然后对内层循环挨个比较如果有比临时变量小的(大的),则保存到临时变量中,当内层循环结束调换上层循环当前下表和临时变量中保存...
  • 前言数组(一维)去重最原始的方法就是使用双层循环,分别循环原始数组和新建数组;或者我们可以使用indexOf来简化内层的循环;或者可以将原始数组排序完再来去重,这样会减少一个循环,只需要比较前后两个数即可。...

空空如也

空空如也

1 2 3 4
收藏数 67
精华内容 26
关键字:

双层循环效率