java 测试万级、十万级、百万级树形结构数据处理的几种实现方式（递归、stream流、hutool工具类）的效率

卖女孩的小火柴er

已于 2024-04-15 11:08:28 修改

阅读量1.3k

点赞数 27

文章标签： java 数据库 oracle

于 2024-04-12 13:01:04 首次发布

本文链接：https://blog.youkuaiyun.com/m0_65408235/article/details/137674110

版权

文章详细描述了在SpringBoot项目中，使用Stream流、for循环、Hutool工具以及递归方法处理不同规模（万级、十万级、五十万级和百万级）数据库数据的效率对比，发现递归性能最差，其他三种方式差异不大。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一：测试前准备

1: 数据库数据准备

1.1: 数据库建表语句

树形结构表建表语句如下sql所示，


CREATE TABLE `dept` (
  `id` bigint NOT NULL AUTO_INCREMENT,
  `pid` bigint DEFAULT NULL,
  `name` varchar(100) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB  DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;

1.2：创建百万数据

作者采用递归的方式来插入

mysql创建100百万数据步骤如下：

1：创建一个存储过程，在这个存储过程中，我们将循环100万次，每次循环插入一条记录。为了简化父子关系的分配，我们可以简单地将每个100个记录的id作为下一个记录的pid，这样就能创建一个简单的父子结构。第一个记录的pid可以设置为NULL，表示它是顶级父记录。

CREATE PROCEDURE GenerateDeptData()
BEGIN
  DECLARE i INT DEFAULT 1;
  WHILE i <= 1000000 DO
    INSERT INTO dept (pid, name) VALUES (IF(MOD(i, 100) = 1, NULL, i - MOD(i, 100)), CONCAT('Dept ', i));
    SET i = i + 1;
  END WHILE;
END

2：执行存储过程来生成数据：

CALL GenerateDeptData();

2：springboot项目搭建

采用mybatis-plus来实现数据库交互

实体类Dept:

@Data
public class Dept {
    private Long id;
    private Long pid;
    private String name;
    @TableField(exist = false)
    private List<Dept> child;
}

Mapper:

@Mapper
public interface DeptMapper extends BaseMapper<Dept> {
}

Controller:

RestController
public class TestController {
    @Resource
    private DeptMapper deptMapper;
    //stream流方式
    @GetMapping("/test")
    public List<Dept> get() {
        QueryWrapper<Dept> wrapper = new QueryWrapper<>();
        wrapper.between("id",1,10000);
        List<Dept> depts = deptMapper.selectList(wrapper);
        Map<Long, List<Dept>> collect =
                depts.stream().collect(Collectors.groupingBy(Dept::getPid));
        return depts.stream()
                .peek(e -> e.setChild(collect.get(e.getId())))
                .filter(e -> e.getPid() == 0)
                .collect(Collectors.toList());
    }
    //hutool工具类方式
    @GetMapping("/test2")
    public List<Tree<Long>> get2() {
        QueryWrapper<Dept> wrapper = new QueryWrapper<>();
        wrapper.between("id",1,10000);
        List<Dept> depts = deptMapper.selectList(wrapper);
        List<TreeNode<Long>> collect = depts.stream().map(e -> {
            TreeNode<Long> longTreeNode = new TreeNode<>();
            longTreeNode.setId(e.getId());
            longTreeNode.setParentId(e.getPid());
            longTreeNode.setName(e.getName());
            return longTreeNode;
        }).collect(Collectors.toList());
        return TreeUtil.build(collect, 0L);
    }
    //stream流的for语句方式
    @GetMapping("/test3")
    public List<Dept> get3() {
        QueryWrapper<Dept> wrapper = new QueryWrapper<>();
        wrapper.between("id",1,10000);
        List<Dept> depts = deptMapper.selectList(wrapper);
        Map<Long, List<Dept>> collect = new HashMap<>();
        List<Dept> rootDepts = new ArrayList<>();
        for (Dept dept : depts) {
            collect.computeIfAbsent(dept.getPid(), k -> new ArrayList<>()).add(dept);
            if (dept.getPid() == 0) {
                rootDepts.add(dept);
            }
        }
        for (Dept dept : depts) {
            dept.setChild(collect.get(dept.getId()));
        }
        return rootDepts;
    }
    //递归方式
    @GetMapping("/test4")
    public List<Dept> get4() {
        QueryWrapper<Dept> wrapper = new QueryWrapper<>();
        wrapper.between("id",1,10000);
        List<Dept> depts = deptMapper.selectList(wrapper);
        List<Dept> returnList = new ArrayList<>();
        List<Long> collect = depts.stream().map(Dept::getId).collect(Collectors.toList());
        for (Dept dept : depts) {
            //说明是顶级节点
            if(!collect.contains(dept.getPid())) {
                buildTree(depts,dept);
                returnList.add(dept);
            }
        }
        return returnList;
    }
    public void buildTree(List<Dept> list,Dept dept) {
        List<Dept> childList = list.stream().filter(e -> e.getPid().equals(dept.getId())).collect(Collectors.toList());
        dept.setChild(childList);
        for (Dept dept1 : childList) {
            if(hasChild(list,dept1)){
                buildTree(list,dept1);
            }
        }
    }
    public boolean hasChild(List<Dept> list,Dept dept) {
        List<Dept> childList = list.stream().filter(e -> e.getPid().equals(dept.getId())).collect(Collectors.toList());
        return !childList.isEmpty();
    }
}