首页 > 软件编程 > java > java组装树形结构List

java组装树形结构List问题

2023-08-26 14:12:22 作者：ChuanDD

这篇文章主要介绍了java组装树形结构List问题,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教

java组装树形结构List

实现方式千千万，下面是本人实现的一种方式。

业务需求

将一个内关联表中的数据，组装成树形结构。

业务表：使用parent_id关联父节点id，父级根节点的parent_id为0。

树形结构

[
  {
    "id": 1, 
    "parentId": 0, 
    "userName": "AA", 
    "children": [
      {
        "id": 11, 
        "parentId": 1, 
        "userName": "AA-AA", 
        "children": [
          {
            "id": 111, 
            "parentId": 11, 
            "userName": "AA-AA-AA", 
            "children": []
          }
        ]
      }
    ]
  },
  {
    "id": 2, 
    "parentId": 0, 
    "userName": "BB", 
    "children": [
      {
        "id": 22, 
        "parentId": 2, 
        "userName": "BB-BB", 
        "children": []
      }
    ]
  }
]

java代码

UserTree实体类：

import java.util.List;
public class UserTree {
    private Integer id;
    private Integer parentId;
    private String userName;
    private List<UserTree> children;
    public UserTree(Integer id, Integer parentId, String userName) {
        this.id = id;
        this.parentId = parentId;
        this.userName = userName;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public Integer getParentId() {
        return parentId;
    }
    public void setParentId(Integer parentId) {
        this.parentId = parentId;
    }
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    public List<UserTree> getChildren() {
        return children;
    }
    public void setChildren(List<UserTree> children) {
        this.children = children;
    }
    @Override
    public String toString() {
        return "UserTree{" +
                "id=" + id +
                ", parentId=" + parentId +
                ", userName='" + userName + '\'' +
                ", children=" + children.toString() +
                '}';
    }
}

核心逻辑代码

import java.util.ArrayList;
import java.util.List;
/**
 * 测试用户树形结构
 * @author 测试
 */
public class TestUserTree {
    public static void main(String[] args) {
        // 模拟从数据库表中查询出的 user数据list
        List<UserTree> userDataList = new ArrayList<>();
        userDataList.add(new UserTree(1, 0, "AA"));
        userDataList.add(new UserTree(11, 1, "AA-AA"));
        userDataList.add(new UserTree(111, 11, "AA-AA-AA"));
        userDataList.add(new UserTree(2, 0, "BB"));
        userDataList.add(new UserTree(22, 2, "BB-BB"));
        // 父级根节点 list
        List<UserTree> rootUserList = new ArrayList<>();
        // 从查询出的数据中 获取 所有父级根节点
        for (UserTree user : userDataList) {
            // parentId为0的是父级
            if (user.getParentId().equals(0)) {
                rootUserList.add(user);
            }
        }
        // 最终的树形结构list
        List<UserTree> userTreeList = new ArrayList<>();
        // 构建树形结构
        for (UserTree rootUser : rootUserList) {
            UserTree user = buildUserTree(userDataList, rootUser);
            userTreeList.add(user);
        }
        System.out.println(userTreeList);
    }
    /**
     * 递归构建树形结构
     * @param userDataList 所有的用户数据list
     * @param userTree 用户对象
     * @return
     */
    public static UserTree buildUserTree(List<UserTree> userDataList, UserTree userTree) {
        List<UserTree> childrenUserList = new ArrayList<>();
        for (UserTree user : userDataList) {
            // 当前数据的 parentId 等于 父节点的 id，则该数据是当前父级节点的子级。
            if (user.getParentId().equals(userTree.getId())) {
                // 递归调用
                childrenUserList.add(buildUserTree(userDataList, user));
            }
        }
        userTree.setChildren(childrenUserList);
        return userTree;
    }
}

最终打印出的就是上方提到的树形结构。

核心的思路就是，使用递归的方式逐级遍历所有的用户数据，找出每一层父级节点的子级，将子级节点保存为list赋值给父级的children字段。

java组装树形结构优化思路

项目中经常会遇到前端需要展现树形结构数据，比如菜单树、省市区联动，在小数据量的时候，不管用什么算法都可以，但一旦数据大，不同算法的差距就会非常的大。

公司的项目中老代码用的是递归方法构建树结构，2万多个数据就需要跑20s，把生产服务器CPU都跑满了，于是对该方法进行重构。

思路

为了不影响传入的数据，需要拷贝原数据集合。（增加和删除频繁，使用LinkedList结构）
拷贝的过程中，一并收集每个节点的id，后面用来判断每个节点的parentId是否存在，不存在则认为是根节点。（为了在比较的时候更快速，使用Set结构）
将集合中的数据用parentId作为key，放入map中，得到Map<String, List<TreeNode>>结构数据。（利用Java8的Collectors.groupingBy获取）
遍历集合，将节点的id作为key，从第3步组装的map中获取子节点，利用Java的地址引用构建树，并且将不是根节点的数据从集合移出。

实现代码（可以直接运行）

TreeNode

@Data
public class TreeNode {
  private String id;
  private String code;
  private String name;
  private String parentId;
  private List<TreeNode> children;
}

实现代码

  public static List<TreeNode> buildTree(List<Map<String, Object>> oriDataMapList) {
    // 判空
    if (oriDataMapList == null || oriDataMapList.isEmpty()) {
      return new ArrayList<>();
    }
    // 最终要返回的只保留根节点的集合，增删比较多，使用LinkedList
    List<TreeNode> respTreeNodeList = new LinkedList<>();
    // id集合，后面用来判断parentId是否在oriTreeNodeList存在，如果存在则说明是子节点，不存在则认为是根节点
    Set<String> idSet = new HashSet<>(oriDataMapList.size());
    // 拷贝数据
    TreeNode treeNode;
    for (Map map : oriDataMapList) {
      treeNode = new TreeNode();
      treeNode.setId((String) map.get("id"));
      treeNode.setCode((String) map.get("code"));
      treeNode.setName((String) map.get("name"));
      treeNode.setParentId((String) map.get("parentId"));
      // 遍历的时候顺便保存id集合
      idSet.add(treeNode.getId());
      respTreeNodeList.add(treeNode);
    }
    // 获取由parentId作为key的map，同一个父节点的数据已经被汇总成一个list，通过key就能获取
    Map<String, List<TreeNode>> parentIdMap = respTreeNodeList.stream().collect(Collectors.groupingBy(item -> item.getParentId() != null ? item.getParentId() : "nonParent"));
    // 设置children，并从根节点移出不是父节点的数据
    Iterator<TreeNode> iterator = respTreeNodeList.iterator();
    TreeNode node;
    while (iterator.hasNext()) {
      node = iterator.next();
      // 获取当前结点的子节点集合
      node.setChildren(parentIdMap.get(node.getId()));
      // 如果父id在id集合中存在，则说明他不是根节点，移除
      if (idSet.contains(node.getParentId())) {
        iterator.remove();
      }
    }
    return respTreeNodeList;
  }

测试代码

  public static void main(String[] args) {
    // 模拟测试数据
    List<Map<String, Object>> mapList = new ArrayList<>();
    Map<String, Object> map;
    for (int i = 0; i < 1000; i++) {
      String parentId = String.valueOf(UUID.randomUUID());
      map = new HashMap<>();
      map.put("id", parentId);
      // %03d 长度为3，不够的补0
      map.put("code", String.format("%03d", i));
      mapList.add(map);
      for (int j = 0; j < 1000; j++) {
        map = new HashMap<>();
        String id = String.valueOf(UUID.randomUUID());
        map.put("id", id);
        map.put("code", String.format("%03d", i) + String.format("%03d", j));
        map.put("parentId", parentId);
        mapList.add(map);
      }
    }
    long start = System.currentTimeMillis();
    List<TreeNode> treeNodeList = buildTree(mapList);
    String msg = String.format("组装【%s】条数据，耗时【%s】ms", mapList.size(), (System.currentTimeMillis() - start));
    System.out.println(msg);
  }

运行结果

组装【1001000】条数据，耗时【417】ms

结论：可以看到，跑一百万的数据耗时只有不到0.5s，速度大大优化

总结

以上为个人经验，希望能给大家一个参考，也希望大家多多支持脚本之家。