简洁版
package com.example.listsorttest.collectionsort.TreeTest1;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.experimental.Accessors;
import java.util.ArrayList;
import java.util.List;
@Data
@AllArgsConstructor
public class Department {
private Integer depId;
private String information;
private Integer parentId;
private List<Department> children=new ArrayList<>();
private Integer number;
public List<Department> getChildren() {
return children;
}
public void setChildren(List<Department> children) {
this.children = children;
}
public Department(Integer depId,String information, Integer parentId, Integer number) {
this.depId = depId;
this.information = information;
this.parentId = parentId;
this.number = number;
}
}
package com.example.listsorttest.collectionsort.TreeTest1;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class TestTree {
public static void main(String[] args) {
List<Department> list = Arrays.asList(
new Department(1,"根节点0",0,1),
new Department(2,"父节点1",1,2),
new Department(3,"根节点0",0,3),
new Department(4,"父节点3",3,4),
new Department(5,"父节点2",2,5),
new Department(6,"父节点4",4,6),
new Department(7,"父节点2",2,7)
);
List<Department> departments = listTree(list);
System.out.println(departments);
}
public static List<Department> listTree(List<Department> list) {
List<Department> arrayList = new ArrayList<>();
for (Department department : list) {
if(department.getParentId() == 0) {
arrayList.add(findChildren(department,list));
}
}
return arrayList;
}
public static Department findChildren(Department dep,List<Department> list) {
for (Department deps : list) {
if(dep.getDepId() == deps.getParentId()) {
if(dep.getChildren() == null) {
dep.setChildren(new ArrayList<Department>());
}
dep.getChildren().add(findChildren(deps,list));
}
}
return dep;
}
}
复杂版
package com.example.listsorttest.collectionsort.TreeTest;
import lombok.Data;
import sun.reflect.generics.tree.Tree;
import java.util.ArrayList;
import java.util.List;
@Data
public class TreeNode {
private Integer id;
private Integer parentId;
private String label;
private List<TreeNode> children = new ArrayList<>();
public TreeNode(Integer id, Integer parentId, String label) {
this.id = id;
this.parentId = parentId;
this.label = label;
}
}
package com.example.listsorttest.collectionsort.TreeTest;
import java.util.ArrayList;
import java.util.List;
public class TreeBuild {
// 理解思路(个人):
//1、首先获取所有的根节点(顶级节点),即根节点的parentId = 0。
//2、根据每一个根节点,与所有节点集合(数据)进行判断,当前节点是否为其下的子节点。
//3、若是,则递归调用构建树形;若不是,则表明该节点不属于其下子节点。
//4、应继续循环判断节点父子关系,直到所有节点与根节点判断完毕。
public List<TreeNode> nodeList = new ArrayList<>();
/**
* 构造方法
* 将数据集合赋值给nodeList,即所有数据作为所有节点
*/
public TreeBuild(List<TreeNode> nodeList) {
this.nodeList = nodeList;
}
/**
* 获取需构建的所有根节点(顶级节点) “0”
* @return
*/
public List<TreeNode> getRootNode() {
// 保存所有根节点(所有根节点的数据)
List<TreeNode> rootNodeList = new ArrayList<>();
// 查询出的每一条数据(节点)
for (TreeNode treeNode : nodeList) {
// 判断当前节点是否为根节点,
if(0 == treeNode.getParentId()) {
// 是,添加
rootNodeList.add(treeNode);
}
}
return rootNodeList;
}
/**
* 根据没一个顶级节点(根节点)进行构建树形结构
* @return
*/
public List<TreeNode> buildTree() {
// 保持一个顶级节点所构建出来的完整树形
List<TreeNode> treeNodes = new ArrayList<TreeNode>();
// getRootNode() 获取所有的根节点
for (TreeNode treeRootNode : getRootNode()) {
// 将顶级节点进行构建子树
treeRootNode = buildChildTree(treeRootNode);
// 完成一个顶级节点所构建的树形,增加进来
treeNodes.add(treeRootNode);
}
return treeNodes;
}
/**
* 递归,构建子树形结构
* @param pNode
* @return
*/
public TreeNode buildChildTree(TreeNode pNode) {
List<TreeNode> childTree = new ArrayList<>();
// 所有节点集合(所有数据)
for (TreeNode treeNode : nodeList) {
// 判断当前节点的父节点ID是否等于根节点的id,即当前节点为其下的子节点
if(treeNode.getParentId().equals(pNode.getId())) {
// 在递归进行判断当前节点的情况,调用自身方法
childTree.add(buildChildTree(treeNode));
}
}
// for循环结束,即节点下没有任何节点,树形构建结束,设置树结果
pNode.setChildren(childTree);
return pNode;
}
}
package com.example.listsorttest.collectionsort.TreeTest;
import java.util.ArrayList;
import java.util.List;
public class TreeTest {
public static void main(String[] args) {
List<TreeNode> treeNodeList = new ArrayList<>();
treeNodeList.add(new TreeNode(1,0,"顶级节点A"));
treeNodeList.add(new TreeNode(2,0,"顶级节点B"));
treeNodeList.add(new TreeNode(3,1,"父节点是A"));
treeNodeList.add(new TreeNode(4,2,"父节点是B"));
treeNodeList.add(new TreeNode(5,2,"父节点是B"));
treeNodeList.add(new TreeNode(6,3,"父节点的id是3"));
TreeBuild treeBuild = new TreeBuild(treeNodeList);
List<TreeNode> treeNodes = treeBuild.buildTree();
System.out.println(treeNodes);
}
}