两个List循环效率对比 List转Map 循环效率对比 Listmap 循环效率对比

一、情景描述

1、在微服务开发中，如：查询用户列表 userList，需要关联查询每个用户下面的文件信息，由于数据库层隔离，不能直接进行 left join ，则需要通过关联查询文件服务，来获取每个用户下的文件信息，伪代码如下：

List<User> userList = userService.getList(xx);

List<UserFile> userFileList = fileService.getList(userIdList);

2、再通过关联的id，进行匹配；一般进行匹配的方式有2种，

同时遍历 userList 和 userFileList ，逐一匹配；
其中一个 userList 转换为 userListMap，然后遍历另外一个 userFileList ，再进行匹配

3、本文将模拟以上2种情况，进行测试对比匹配的效率，用于总结后续的开发中，遇到类似的情况，该如何处理的，经验总结。

二、代码实现

1、定义一个普通的内部类，有3个属性：

static class User{
    private  Integer id ;
    private String name ;
    private Integer score ;
    // ingnore getter /setter construction
}

2、初始化2个 list ，一个 1w数据，一个10w数据


List<User> list = Lists.newArrayList();
List<User> list10 = Lists.newArrayList();

@Before
public void before() throws Exception {
    int n1 = 10_000;
    int n2 = 1_00_000;
    System.out.println("n1 ="+n1 +" ; n2="+n2);

    initList(n1);
    initList2(n2);

    System.out.println("初始化 list 完成 , list = "+ list.size() + " list10 = "+ list10.size());
}

private void initList(int n) {
    for (int i = 0; i < n; i++) {
        list.add(new User(i,"小明"+i));
    }
}

private void initList2(int n2) {
    for (int i = 0; i < n2; i++) {
        list10.add(new User(i,"小明"+i, new Random().nextInt()));
    }
}

3、1w List 循环 10w List ：

@Test
public void listCompare() throws Exception {
    final StopWatch stopWatch = StopWatch.createStarted();
    list.forEach(e->{
        list10.forEach(e2->{
            if(e.getId().equals(e2.getId())){
                e.setScore(e2.getScore());
            }
        });
    });
    System.out.println("测试匹配情况： list, 100=" + list.get(100).getScore()
            + " ; list10 , 100="+list10.get(100).getScore());
    stopWatch.stop();
    System.out.println("1w List 循环 10w List,耗时：" + stopWatch.getTime()+" ms");
}

3.1、输出结果如下：

n1 =10000 ; n2=100000
初始化 list 完成 , list = 10000 list10 = 100000
测试匹配情况： list, 100=1980067001 ; list10 , 100=1980067001
1w List 循环 10w List,耗时：7370 ms

4、10w List 循环 1w List

@Test
public void list10Compare() throws Exception {
    final StopWatch stopWatch = StopWatch.createStarted();
    list10.forEach(e->{
        list.forEach(e2->{
            if(e.getId().equals(e2.getId())){
                e2.setScore(e.getScore());
            }
        });
    });
    System.out.println("测试匹配情况： list, 100=" + list.get(100).getScore()
            + " ; list10 , 100="+list10.get(100).getScore());
    stopWatch.stop();
    System.out.println("10w List 循环 1w List,耗时：" + stopWatch.getTime()+" ms");
}

4.1、输出结果如下：

n1 =10000 ; n2=100000
初始化 list 完成 , list = 10000 list10 = 100000
测试匹配情况： list, 100=-110042713 ; list10 , 100=-110042713
10w List 循环 1w List,耗时：1489 ms

5、 1w List转Map 循环 10w List 对比：

@Test
public void listMapCompare() throws Exception {
    final StopWatch stopWatch = StopWatch.createStarted();
    final Map<Integer, User> map = list.stream().collect(Collectors.toMap(k -> k.getId(), v -> v));
    list10.forEach(e->{
        final User user = map.get(e.getId());
        if(Objects.nonNull(user)){
            user.setScore(e.getScore());
        }
    });

    System.out.println("测试匹配情况： list, 100=" + list.get(100).getScore()
            + " ; list10 , 100="+list10.get(100).getScore());
    stopWatch.stop();
    System.out.println("1w List转Map 循环 10w List 对比,耗时：" + stopWatch.getTime()+" ms");
}

5.1、输出结果如下：

n1 =10000 ; n2=100000
初始化 list 完成 , list = 10000 list10 = 100000
测试匹配情况： list, 100=690010328 ; list10 , 100=690010328
1w List转Map 循环 10w List 对比,耗时：49 ms

6、10w List转Map 循环 1w List 对比：

@Test
public void list10MapCompare() throws Exception {
    final StopWatch stopWatch = StopWatch.createStarted();
    final Map<Integer, User> map = list10.stream().collect(Collectors.toMap(k -> k.getId(), v -> v));
    list.forEach(e->{
        final User user = map.get(e.getId());
        if(Objects.nonNull(user)){
            e.setScore(user.getScore());
        }
    });

    System.out.println("测试匹配情况： list, 100=" + list.get(100).getScore()
            + " ; list10 , 100="+list10.get(100).getScore());
    stopWatch.stop();
    System.out.println("10w List转Map 循环 1w List 对比,耗时：" + stopWatch.getTime()+" ms");
}

6.1、输出结果如下：

n1 =10000 ; n2=100000
初始化 list 完成 , list = 10000 list10 = 100000
测试匹配情况： list, 100=-623027169 ; list10 , 100=-623027169
10w List转Map 循环 1w List 对比,耗时：56 ms