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 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 getChildren() {
        return children;
    }

    public void setChildren(List 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;


public class TestUserTree {
    public static void main(String[] args) {
        // 模拟从数据库表中查询出的 user数据list
        List 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 rootUserList = new ArrayList<>();
        // 从查询出的数据中 获取 所有父级根节点
        for (UserTree user : userDataList) {
            // parentId为0的是父级
            if (user.getParentId().equals(0)) {
                rootUserList.add(user);
            }
        }

        // 最终的树形结构list
        List userTreeList = new ArrayList<>();
        // 构建树形结构
        for (UserTree rootUser : rootUserList) {
            UserTree user = buildUserTree(userDataList, rootUser);
            userTreeList.add(user);
        }

        System.out.println(userTreeList);

    }

    
    public static UserTree buildUserTree(List userDataList, UserTree userTree) {
        List 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字段。

注：转载请注明出处。