Java树形结构封装+树形模糊查询支持。

 1.组装树形的数据类CateTreeVO

package com.cloud.fod.beans.vo;

import com.alibaba.excel.util.CollectionUtils;
import com.alibaba.fastjson.annotation.JSONField;
import lombok.Data;
import org.apache.commons.lang3.StringUtils;

import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.List;

/**
 * @author yb
 * @date 2022/11/28 14:34
 */
@Data
public class CateTreeVO {
    /**
     * 主键id
     */
    private String Id;
    /**
     * 上级id
     */
    private String pId;
    /**
     * 类型名称
     */
    private String cateName;
    /**
     * 类型编码
     */
    private String cateCode;
    /**
     * 状态
     */
    private Integer status;
    /**
     * 上级名称
     */
    private String largeTypeName;
    /**
     * 定制标志
     */
    private Integer customFlag;
    /**
     * 客户名称
     */
    private String customerName;
    /**
     * 定制时间
     */
    @JSONField(format = "yyyy-MM-dd HH:mm:ss")
    private Date customTime;

    private List<CateTreeVO> children;

    public CateTreeVO(String id, String pId, String cateName, String cateCode, Integer status, String largeTypeName, Integer customFlag, String customerName, Date customTime) {
        Id = id;
        this.pId = pId;
        this.cateName = cateName;
        this.cateCode = cateCode;
        this.status = status;
        this.largeTypeName = largeTypeName;
        this.customFlag = customFlag;
        this.customerName = customerName;
        this.customTime = customTime;
    }

    /**
     * 原始数据先转成树结构
     * @param treeList
     * @return
     */
    public static List<CateTreeVO> recursionMethod(List<CateTreeVO> treeList) {
        List<CateTreeVO> trees = new ArrayList<>();
        for (CateTreeVO tree : treeList) {
            // 找出父节点
            if (StringUtils.isEmpty(tree.getPId())) {
                // 调用递归方法填充子节点列表
                trees.add(findChildren(tree, treeList));
            }
        }
        return trees;
    }

    public static CateTreeVO findChildren(CateTreeVO tree, List<CateTreeVO> treeList) {
        for (CateTreeVO node : treeList) {
            if (tree.getId().equals(node.getPId())) {
                if (tree.getChildren() == null) {
                    tree.setChildren(new ArrayList<>());
                }
                // 递归 调用自身
                tree.getChildren().add(findChildren(node, treeList));
            }
        }
        return tree;
    }


    /**
     * 再通过树结构去模糊查询
     * @param data
     * @param keyword
     * @return
     */
    public static List<CateTreeVO> filterTreeByKeyWord(List<CateTreeVO> data, String keyword) {

        if (CollectionUtils.isEmpty(data)) {
            return data;
        }
        filter(data, keyword);
        return data;
    }

    /**
     * 递归方法
     * @param list 任意层级的节点
     * @param keyword 关键字
     */
    public static void filter(List<CateTreeVO> list, String keyword){
        Iterator<CateTreeVO> parent = list.iterator();
        while (parent.hasNext()){
            //当前节点
            CateTreeVO t = parent.next();
            if (StringUtils.isNotEmpty(keyword) && !t.getCateName().contains(keyword)) {
                //当前节点不包含关键字，继续遍历下一级
                // 取出下一级节点
                List<CateTreeVO> children = t.getChildren();
                // 递归
                if (!CollectionUtils.isEmpty(children)) {
                    filter(children, keyword);
                }
                //下一级节点都被移除了，那么父节点也移除，因为父节点也不包含关键字
                if (CollectionUtils.isEmpty(t.getChildren())) {
                    parent.remove();
                }
            } else {
                //当前节点包含关键字，继续递归遍历
                //子节点递归如果不包含关键字则会进入if分支被删除
                List<CateTreeVO> children = t.getChildren();
                // 递归
                if (!CollectionUtils.isEmpty(children)) {
                    filter(children, keyword);
                }
            }
        }
    }
}

 2.Controller 调用数据。

@RequestMapping("/Cate")
@RestController
public class TFodCateController {

  @PostMapping("/tree/list")
    public Result getCateTreeList(String typeName){
        //查询全部数据
        List<TFodCateBean> fodCateBeanList = tFodCateService.selectList(new EntityWrapper<>());
        List<CateTreeVO> cateTreeVOS = new ArrayList<>();
        for (TFodCateBean pt : fodCateBeanList) {
            cateTreeVOS.add(new CateTreeVO(pt.getFodCateId(), pt.getLargeType(), pt.getCateName(),pt.getCateCode(),pt.getStatus(),pt.getLargeTypeName(),pt.getCustomFlag(),pt.getCustomerName(),pt.getCustomTime()));
        }
        List<CateTreeVO> cateTreeData = CateTreeVO.recursionMethod(cateTreeVOS);
        // 进行模糊查询
        if (StringUtils.isNotEmpty(typeName)){
            CateTreeVO.filterTreeByKeyWord(cateTreeData,typeName);
        }
        return Result.ok(cateTreeData);
    }

}