TreeUtils 树工具类

数据展示：

如图：部门树数据  ，树形的基础数据 id  、 parentId 、label 便可形成

嵌套对象字段如下：{id: 103, parentId: 101, label: "研发部门", weight: 1}

一、工具类 

继承了 hutoo 的工具类 TreeUtil （引入hutool 依赖）

@NoArgsConstructor(access = AccessLevel.PRIVATE)
public class TreeBuildUtils extends TreeUtil {

    /**
     * 根据前端定制差异化字段
     */
    public static final TreeNodeConfig DEFAULT_CONFIG = TreeNodeConfig.DEFAULT_CONFIG.setNameKey("label");

    /**
     * <简述>
     * <详细描述>
     * @author syf
     * @date 2024/8/15 11:27
     * @param list 提供的集合
     * @param nodeParser 节点解析器
     * @return java.util.List<cn.hutool.core.lang.tree.Tree < K>>
     */
    public static <T, K> List<Tree<K>> build(List<T> list, NodeParser<T, K> nodeParser) {
        if (CollUtil.isEmpty(list)) {
            return null;
        }
        // 获取父节点
        K k = ReflectUtils.invokeGetter(list.get(0), "parentId");
        return TreeUtil.build(list, k, DEFAULT_CONFIG, nodeParser);
    }

}

 TreeNodeConfig 树形需要的字段：可以通过set字段修改

public class TreeNodeConfig implements Serializable {
    private static final long serialVersionUID = 1L;
    public static TreeNodeConfig DEFAULT_CONFIG = new TreeNodeConfig();
    private String idKey = "id";
    private String parentIdKey = "parentId";
    private String weightKey = "weight";
    private String nameKey = "name";
    private String childrenKey = "children";
    private Integer deep;

。。。。。省里get  set

 TreeUtil  方法展示：树形构建已经操作节点方法

二、准备简单树形数据

@Slf4j
public class TestTreeNode {
   static List<TreeNode<Integer>> createTreeNodes(){
       List<TreeNode<Integer>> list = new ArrayList<>();
       TreeNode<Integer>  root= new TreeNode<>();
       root.setName("总公司");
       root.setId(1);
       root.setParentId(0);

       TreeNode<Integer>  node1= new TreeNode<>();
       node1.setName("分子公司1");node1.setId(2);node1.setParentId(1);


       TreeNode<Integer>  node2= new TreeNode<>();
       node2.setName("财务部");node2.setId(3);node2.setParentId(2);
       TreeNode<Integer>  node3= new TreeNode<>();
       node3.setName("开发部").setId(4).setParentId(2);

       list.add(root);
       list.add(node1);
       list.add(node2);
       list.add(node3);
       return list;
   }

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

    static void  buildSingle(){
        List<TreeNode<Integer>> list = createTreeNodes();
        Tree<Integer> integerTree = TreeBuildUtils.buildSingle(list);
        Console.log(integerTree);
    }


}

 打印结果：

null[0]
  总公司[1]
    分子公司1[2]
      财务部[3]
      开发部[4]

三、测试所有常用树形方法，并附上DEMO演示

1. 构建树形
2. 获取指定节点
3. 添加节点
4. 移除节点
5. 遍历
6. 过滤
7. 克隆

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

    static void  buildSingle(){
        List<TreeNode<Integer>> list = createTreeNodes();

        //build 对比上面 去掉最外层 null 的父节点
        List<Tree<Integer>> build = TreeBuildUtils.build(list);
        Console.log(build);


        Console.log("-------------------------------------------测试开始------------------------------------------------");

        //原生 构建树结构
        Tree<Integer> integerTree = TreeBuildUtils.buildSingle(list);
        Console.log(integerTree);

        // 获取父节点
        Tree<Integer> parent = integerTree.getParent();
        Console.log("getParent->{}", parent);
        // 获取节点
        Tree<Integer> node = integerTree.getNode(2);
        Console.log("getNode->{}", node);
        // 获取父节点名称
        List<CharSequence> parentsName = integerTree.getParentsName(4, true);
        Console.log("getParentsName->{}", parentsName);
        // 获取配置
        TreeNodeConfig config = integerTree.getConfig();


        // 添加子节点
//        Tree<Integer> integerTree1 = integerTree.addChildren(node);
//        Console.log("addChildren->{}", integerTree1);
        // 判断是否有子节点
        boolean b = integerTree.hasChild();
        Console.log("hasChild->{}", b);
        // 获取子节点
        List<Tree<Integer>> children = integerTree.getChildren();
        Console.log("getChildren->{}", children);

        //遍历整数树结构，并打印每个节点
        integerTree.walk(new Consumer<Tree<Integer>>() {
            @Override
            public void accept(Tree<Integer> integerTree) {
                // 打印节点
                Console.log("walk->{}", integerTree);
            }
        });


        //根据是否包含特定名称（如“分子公司”）来筛选树结构数据
        Tree<Integer> filterNew = integerTree.filterNew(new Filter<Tree<Integer>>() {
            @Override
            public boolean accept(Tree<Integer> integerTree) {
                if (null != integerTree.getName() && integerTree.getName().toString().contains("分子公司")) {
                    return true;
                }
                return false;
            }
        });
        Console.log("filterNew->{}", filterNew);


        // 创建一个过滤器，用于筛选出名称中包含"分子公司"的Tree对象
        Tree<Integer> filter = filterNew.filter(new Filter<Tree<Integer>>() {
            @Override
            public boolean accept(Tree<Integer> integerTree) {
                if (null != integerTree.getName() && integerTree.getName().toString().contains("分子公司")) {
                    return true;
                }
                return false;
            }
        });
        Console.log("filter->{}", filter);


        // 克隆一个整数树结构
        Tree<Integer> integerTree2 = integerTree.cloneTree();
        Console.log("cloneTree->{}", integerTree2);


    }

测试结果：

null[0]
  总公司[1]
    分子公司1[2]
      财务部[3]
      开发部[4]

[总公司[1]
  分子公司1[2]
    财务部[3]
    开发部[4]
]
getParent->null
getNode->分子公司1[2]
  财务部[3]
  开发部[4]

getParentsName->[开发部, 分子公司1, 总公司]
hasChild->true
getChildren->[总公司[1]
  分子公司1[2]
    财务部[3]
    开发部[4]
]
walk->null[0]
  总公司[1]
    分子公司1[2]
      财务部[3]
      开发部[4]

walk->总公司[1]
  分子公司1[2]
    财务部[3]
    开发部[4]

walk->分子公司1[2]
  财务部[3]
  开发部[4]

walk->财务部[3]

walk->开发部[4]

filterNew->null[0]
  总公司[1]
    分子公司1[2]
      财务部[3]
      开发部[4]

filter->null[0]
  总公司[1]
    分子公司1[2]
      财务部[3]
      开发部[4]

cloneTree->null[0]
  总公司[1]
    分子公司1[2]
      财务部[3]
      开发部[4]


Process finished with exit code 0