java递归生成树

实现步骤:

创建一个生成树的基类TreeNode;

package permission;


import java.util.ArrayList;
import java.util.List;


public class TreeNode {
private String id;  
    private String name;  
    private String desc;  
    private String pid;  
    private List<TreeNode> children;  
    public TreeNode() {  
        super();  
    }  
      
    public TreeNode(String id, String name, String desc, String pid) {  
        super();  
        this.id = id;  
        this.name = name;  
        this.desc = desc;  
        this.pid = pid;  
        this.children = new ArrayList<TreeNode>();  
    }  
  
  
    public String getId() {  
        return id;  
    }  
    public void setId(String id) {  
        this.id = id;  
    }  
    public String getName() {  
        return name;  
    }  
    public void setName(String name) {  
        this.name = name;  
    }  
    public String getDesc() {  
        return desc;  
    }  
    public void setDesc(String desc) {  
        this.desc = desc;  
    }  
    public String getPid() {  
        return pid;  
    }  
    public void setPid(String pid) {  
        this.pid = pid;  
    }  
  
    public List<TreeNode> getChildren() {  
        return children;  
    }  
  
    public void setChildren(List<TreeNode> children) {  
        this.children = children;  
    }  

}

测试类:

package permission;


import java.util.ArrayList;
import java.util.List;


import com.alibaba.fastjson.JSON;


public class RecursiveTree {
public static void main(String[] args) {
TreeNode root = new TreeNode("1", "中国", "中国", "");
 TreeNode node1 = new TreeNode("11", "北京", "北京", "1");  
       TreeNode node2 = new TreeNode("12", "上海", "上海", "1");  
       TreeNode node3 = new TreeNode("13", "山东", "山东", "1");  
       TreeNode node4 = new TreeNode("131", "潍坊", "潍坊", "13");  
       TreeNode node5 = new TreeNode("1311", "安丘", "安丘", "131");  
       TreeNode node6 = new TreeNode("111", "朝阳区", "朝阳区", "11");  
       List<TreeNode> nodes = new ArrayList<TreeNode>();
       nodes.add(root);  
       nodes.add(node1);  
       nodes.add(node2);  
       nodes.add(node3);  
       nodes.add(node4);  
       nodes.add(node5);  
       nodes.add(node6);
       System.out.println(switchNodeListToTree(nodes));  
}
/**
* @author zheng
* 自动将节点数据转化为树结构
* @method switchNodeListToTree
* @param nodes
* @return
* @return String
* @date 2018年4月12日 上午9:33:01
*/
public static String switchNodeListToTree(List<TreeNode> nodes){
TreeNode root = getRoot(nodes);
root = recursive(root, nodes);  
        return JSON.toJSONString(root, true); 
}
/**
* @author zheng
* 递归添加子节点
* @method recursive
* @param node
* @param nodes
* @return
* @return TreeNode
* @date 2018年4月12日 上午9:46:35
*/
public static TreeNode recursive(TreeNode rootNode,List<TreeNode> nodes){
for(TreeNode treeNode :nodes){
if(treeNode.getPid().equals(rootNode.getId())){
rootNode.getChildren().add(treeNode);  
           recursive(treeNode, nodes);
}
}
return rootNode; 
}

public static TreeNode getRoot(List<TreeNode> nodes){
TreeNode root = null;  
        if(nodes != null && nodes.size() > 0){  
            for (TreeNode treeNode : nodes) {  
                if(treeNode.getPid().endsWith("")){  
                    root = treeNode;  
                    break;  
                }  
            }  
        }  
        return root;  
}

}

转换json时候用到的工具类,maven

    <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.47</version>
</dependency>:

/** * 根据等级查询类目树 * * @param level * @return */ @Override public List queryCategoryTree(Integer level) { //查询当前级别下类目 List list = categoryDAO.list(level); //组装好的类目树,返回前端 List categoryTree = new ArrayList(); //所有类目 List allDTOList = new ArrayList(); if (CollectionUtils.isEmpty(list)) { return categoryTree; } for (CategoryDO categoryDO : list) { allDTOList.add(new CategoryTreeDTO().convertDOToDTO(categoryDO)); } //当前等级类目 categoryTree = allDTOList.stream().filter(dto -> level.equals(dto.getLevel())).collect(Collectors.toList()); for (CategoryTreeDTO categoryTreeDTO : categoryTree) { //组装类目为树结构 assembleTree(categoryTreeDTO, allDTOList,Constants.CATEGORY_MAX_LEVEL - level); } return categoryTree; } /** * 组装树 * * @param categoryTreeDTO * @param allList * @param remainRecursionCount 剩余递归次数 * @return */ public CategoryTreeDTO assembleTree(CategoryTreeDTO categoryTreeDTO, List allList, int remainRecursionCount) { remainRecursionCount--; //最大递归次数不超过Constants.CATEGORY_MAX_LEVEL-level次,防止坏数据死循环 if(remainRecursionCount < 0){ return categoryTreeDTO; } String categoryCode = categoryTreeDTO.getCategoryCode(); Integer level = categoryTreeDTO.getLevel(); //到达最后等级树返回 if (Constants.CATEGORY_MAX_LEVEL == level) { return categoryTreeDTO; } //子类目 List child = allList.stream().filter(a -> categoryCode.equals(a.getParentCode())).collect(Collectors.toList()); if (null == child) { return categoryTreeDTO; } categoryTreeDTO.setChildren(child); //组装子类目 for (CategoryTreeDTO dto : child) { assembleTree(dto, allList,remainRecursionCount); } return categoryTreeDTO; }
Java Stream API 提供了一种基于函数式编程风格的数据处理方式,可以用来简化并行操作、数据转换等任务。虽然 Java Streams 并不是直接用于生成树结构的工具,但它们能够非常方便地配合其他 Java 类库(如 Apache Commons Lang 的 RecursiveTreeBuilder 或自定义算法)来构建或操作树形结构。 在讨论如何使用 Java Stream API 来递归生成树之前,我们需要了解基本的树形结构及其关键组件: - **节点**:树的基本单位,通常包含数据和指向其子节点的引用。 - **根节点**:树的最顶级节点,无父节点。 - **子节点**:每个非叶子节点都有一个或多个子节点。 ### 使用 Java Stream 实现树的构建 虽然 Java Stream 主要用于处理集合,并非直接用于递归生成树,但在某种程度上,通过将递归过程转换为迭代形式,我们可以在一定程度上利用 Stream 来构建树状结构。下面是一个简单的示例,展示如何使用 Stream 构建树形结构。假设我们有一个代表树节点的简单类 `TreeNode`: ```java class TreeNode { String value; List<TreeNode> children; public TreeNode(String value) { this.value = value; this.children = new ArrayList<>(); } // 添加子节点 public void addChild(TreeNode child) { children.add(child); } } ``` #### 示例:使用递归来创建树结构 下面的例子展示了如何使用递归Java Streams 的组合来创建树结构。在这个例子中,我们将从一个列表开始,其中包含了父节点与子节点的关系,然后逐步构建树结构。 ```java public class TreeBuilder { public static TreeNode buildTree(List<NodePair> nodePairs) { return nodePairs.stream() .reduce(new TreeNode(null), (parent, next) -> { if (next.getParent() == null || parent.getValue().equals(next.getParent())) { parent.addChild(new TreeNode(next.getValue())); return parent; } else { return null; // 这里只是举例,实际情况下需要更复杂的逻辑来调整路径 } }, (left, right) -> left); // 使用空值作为初始节点,最终返回构建完成的根节点 // NodePair 类表示一个节点及其父节点名称 class NodePair { String value; String parent; public NodePair(String value, String parent) { this.value = value; this.parent = parent; } public String getParent() { return parent; } public String getValue() { return value; } } } } // 测试数据 List<NodePair> nodePairs = Arrays.asList( new NodePair("nodeB", "nodeA"), new NodePair("nodeD", "nodeC"), new NodePair("nodeE", "nodeC") ); TreeNode root = TreeBuilder.buildTree(nodePairs); root.getChildren().forEach(System.out::println); // 打印树的所有节点以验证结果 ``` 请注意,上述代码仅展示了如何将数据映射到树结构的基础概念。实际上,在构建树的过程中可能涉及到更复杂的问题,比如循环依赖检查、优化路径查找或添加额外的属性到节点上等等。在真正的应用中,你可能需要设计更多的辅助类和逻辑来处理各种情况。此外,这个示例并没有使用实际的 Stream 减少机制,而是简单地使用了 reduce 操作来进行构建。对于大型树结构的构建,使用传统的 for 循环或递归可能会更高效。 ### 相关问题: 1. **如何在构建树过程中处理循环依赖问题?** - 当遇到循环依赖时,应采取策略来避免无限递归,例如,可以限制递归深度或使用图论中的拓扑排序来检测和处理循环。 2. **Stream 是否适用于大规模树结构的构建?** - 尽管 Stream API 提供了一个优雅的方式来处理集合和序列化操作,但对于构建大型或极其复杂的树结构,由于内存管理和并行计算的限制,可能需要考虑使用传统循环或其他非函数式编程技术。 3. **在实际项目中应该选择哪种方式构建树结构?** - 这取决于具体的业务需求和系统的性能约束。如果系统允许并发处理并且对代码的简洁性和易读性有较高要求,那么使用 Stream 可能是更好的选择;而对于性能敏感的应用场景,则可能需要权衡代码复杂度和执行效率,考虑使用迭代或其他数据处理机制。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值