使用map，将两层for循环嵌套优化成单层循环

前言

刚入行的时候，我在一家还不错的小公司从事股票交易软件的开发。当时要做一个成交额数据看板的功能，需要从成交额表中查询出指定时间段的数据，按照三个维度处理数据。

编写程序的时候用了三层循环，在测试环境完美测试通过了。但是上生产环境的时候，出现了接口请求五分钟都无反应的问题。经过排查，发现是正式环境数据仓库中的这个表的数据量是亿+级别的，数据处理太久。

我将其中一层循环改成map后，5秒钟就查询出结果了。所以减少循环的层次可以提高代码执行的效率，数据量越大越能体现这个优化。

代码示例

以下是一个使用map，将两层循环优化成一层循环的例子

创建User实体类

package loop;

public class User {
    private String pkUser;
    private String username;
    private String password;
    private Integer roleCode;
    private String roleName;

    public String getPkUser() {
        return pkUser;
    }

    public void setPkUser(String pkUser) {
        this.pkUser = pkUser;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public Integer getRoleCode() {
        return roleCode;
    }

    public void setRoleCode(Integer roleCode) {
        this.roleCode = roleCode;
    }

    public String getRoleName() {
        return roleName;
    }

    public void setRoleName(String roleName) {
        this.roleName = roleName;
    }
}

创建Role实体类

package loop;

public class Role {
    private String pkRole;
    private Integer roleCode;
    private String roleName;

    public String getPkRole() {
        return pkRole;
    }

    public void setPkRole(String pkRole) {
        this.pkRole = pkRole;
    }

    public Integer getRoleCode() {
        return roleCode;
    }

    public void setRoleCode(Integer roleCode) {
        this.roleCode = roleCode;
    }

    public String getRoleName() {
        return roleName;
    }

    public void setRoleName(String roleName) {
        this.roleName = roleName;
    }
}

测试类

package loop;

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

public class LoopTest {
    private static final Integer USER_COUNT = 50000; // 假设有50000个用户
    private static final Integer ROLE_COUNT = 10000; // 假设有10000个角色，实际开发中不会有这么多

    public static void main(String[] args) {
        doubleLayerLoop();
        singleLayerLoop();
    }

    private static List<User> selectAllUser() {
        List<User> userList = new ArrayList<>();
        for (int i = 0; i < USER_COUNT; i++) {
            User user = new User();
            user.setPkUser(UUID.randomUUID().toString());
            user.setUsername(UUID.randomUUID().toString());
            user.setPassword(UUID.randomUUID().toString());
            user.setRoleCode(new Random().nextInt(100));
            userList.add(user);
        }
        return userList;
    }

    private static List<Role> selectAllRole() {
        List<Role> roleList = new ArrayList<>();
        for (int i = 0; i < ROLE_COUNT; i++) {
            Role role = new Role();
            role.setPkRole(UUID.randomUUID().toString());
            role.setRoleCode(i);
            role.setRoleName("角色名称" + i);
            roleList.add(role);
        }
        return roleList;
    }

    private static void doubleLayerLoop() {
        List<User> userList = selectAllUser();
        List<Role> roleList = selectAllRole();

        // 循环次数 = USER_COUNT * ROLE_COUNT = 500000000
        long startTime = System.currentTimeMillis();
        for (User user : userList) {
            for (Role role : roleList) {
                if (user.getRoleCode().equals(role.getRoleCode())) {
                    user.setRoleName(role.getRoleName());
                }
            }
        }
        long endTime = System.currentTimeMillis();

        System.out.println("双层循环需要的时间：" + (endTime - startTime));
    }

    private static void singleLayerLoop() {
        List<User> userList = selectAllUser();
        List<Role> roleList = selectAllRole();

        long startTime = System.currentTimeMillis();
        Map<Integer, String> roleMap = roleList.stream().collect(Collectors.toMap(Role::getRoleCode, Role::getRoleName));
        for (User user : userList) {
            user.setRoleName(roleMap.get(user.getRoleCode()));
        }
        long endTime = System.currentTimeMillis();

        System.out.println("单层循环+map需要的时间：" + (endTime - startTime));
    }
}

运行结果

双层循环需要的时间：4570
单层循环+map需要的时间：61

时间复杂度分析

两层循环：doubleLayerLoop()：O(m + n)
单层循环：singleLayerLoop()：O(m * n)