java递归树型结构通用数据库

使⽤Java将⼀个List运⽤递归转成树形结构案例在开发中，我们会遇到将不同组织架构合并成tree这种树状结构，那么如果做呢？实际上，我们也可以理解为如何将拥有⽗⼦关系的list转成树形结构，⽽这其中主要的⽅法就是递归！1、实体对象：@Datapublic class Node {private Integer id;private String city;private Integer pid;private List<Node> children;public Node(Integer id,String city,Integer pid){this.id = id;this.city = city;this.pid = pid;}}2、转换⼯具类：public class TreeUtils {//把⼀个List转成树static List<Node> buildTree(List<Node> list,Integer pid){List<Node> tree=new ArrayList<>();for(Node node:list){if(Objects.equals(node.getPid(),pid)){tree.add(findChild(node,list));}}return tree;}static Node findChild(Node node, List<Node> list){for(Node n:list){if(Objects.equals(n.getPid(),node.getId())){if(node.getChildren() == null){node.setChildren(new ArrayList<Node>());}node.getChildren().add(findChild(n,list));}}return node;}public static void main(String[] args) {Node node0=new Node(0,"中国",-1);Node node1=new Node(1,"湖北省",0);Node node2=new Node(2,"武汉市",1);Node node3=new Node(3,"洪⼭区",2);Node node4=new Node(4,"宜昌市",1);Node node5=new Node(5,"上海市",0);Node node6=new Node(6,"静安区",5);List<Node> list=new ArrayList<>();list.add(node3);list.add(node4);list.add(node1);list.add(node2);list.add(node5);list.add(node6);list.add(node0);List<Node> nodes = buildTree(list,-1);System.out.println(JSON.toJSONString(nodes));}}3、运⾏结果：这样list就成功转换成为了tree装结构到此这篇关于使⽤Java将⼀个List运⽤递归转成树形结构案例的⽂章就介绍到这了,更多相关Java将list运⽤成树形结构内容请搜索以前的⽂章或继续浏览下⾯的相关⽂章希望⼤家以后多多⽀持！。

java 查询数据库数据递归处理在Java中查询数据库数据并进行递归处理是一个常见的需求，特别是在处理树状结构数据或者具有层级关系的数据时。

通过递归处理，我们可以方便地遍历整个数据集并进行相应的操作。

以下是关于如何在Java中进行数据库数据的递归处理的参考内容：首先，我们需要建立一个数据库连接，可以使用JDBC来实现。

在Java中，我们可以通过JDBC连接到数据库并执行相应的SQL语句来查询数据。

以下是一个简单的示例代码：```javaimport java.sql.Connection;import java.sql.DriverManager;import java.sql.PreparedStatement;import java.sql.ResultSet;import java.sql.SQLException;public class DatabaseUtils {private static final String URL = "jdbc:mysql://localhost:3306/database_name";private static final String USERNAME = "username";private static final String PASSWORD = "password";public static Connection getConnection() {Connection connection = null;try {connection = DriverManager.getConnection(URL, USERNAME, PASSWORD);} catch (SQLException e) {e.printStackTrace();}return connection;}public static void closeConnection(Connection connection) {if (connection != null) {try {connection.close();} catch (SQLException e) {e.printStackTrace();}}}}```在上面的示例代码中，我们通过JDBC建立了一个数据库连接，并提供了一个用于获取数据库连接的方法。

表结构/*** 删除部门删除时从选中级的所有子级** @param dept* @return*/public JsonResult delDept(Dept dept) {JsonResult jr = new JsonResult();Boolean flags=true;try {String str = "";User user=new User();List<Dept> sortList = new ArrayList<Dept>();sortList.add(dept);getDeptSortList(sortList,dept.getId()); //起始根节点id，等级为0for(Dept bean: sortList){user.setDeptId(bean.getId()); //判断部门下面是否有用户List<User> users =userDao.getByDeptIdIsUerOrNO(user);int userSize=users.size();if(userSize>0){jr.setMessage("部门名称：(" + users.get(0).getDeptName() + ")已有用户不能删除");flags=false;break;}}//部门没有被用户使用时才可以册子if(flags){for(Dept bean: sortList){dept.setId(bean.getId());deptDao.delDept(dept);jr.setMessage(SuccessMessageEnum.detele.toDescription());}}jr.setSuccess(true);} catch (Exception e) {log.error("DeptServiceImpl-->delDept:" + e.getMessage());jr.setCode(ExceptionEnum.SystemError.toCode());jr.setMessage(e.getMessage());}return jr;}/*** 删除时递归部门树** @param* @return*/public void getDeptSortList(List<Dept> sortDeptList,Integer parentId)throws Exception { Dept bean = null;//根据选中的部门id得到本部门和第一级所有的子部门的idList<Dept> deptslist=deptDao.getByDeptIdAllSubDeptId(parentId); //;//每次查询出上级为的分类// int deptSize=deptslist.size();if(deptslist.size() > 0){for(int i=0;i<deptslist.size();i++){bean = (Dept)deptslist.get(i);sortDeptList.add(bean);getDeptSortList(sortDeptList,bean.getId()); //递归查询}}}<select id="getByDeptIdAllSubDeptId" resultClass="Dept">select id from report_sys_dept where parent_id=#value#</select><!-- 根据ID删除级联子树，--><delete id="delDept" parameterClass="Dept">delete from report_sys_dept where id = #id#;</delete>事例二表结构为：分类Id SortId所属分类Id ParentID分类名称SortName分类描述SortDesc测试数据：1000 0 A类A类1001 1000 A类_1 A类_11002 1000 A类_1 A类_11003 1001 A类_1_1 A类_1_12000 0 B类B类2001 2000 B类_1 B类_12002 2001 B类_1_1 B类_1_12003 1002 A类_1_1 A类_1_12004 2003 A类_1_1_1 A类_1_1_1java代码：（SortBean类略）/*** 查询分类的树型结构*/p ublic void getSortList(List<SortBean> sortList, Long parentId,int level){SortBean bean = null;List<SortBean> list = new ArrayList<SortBean>();String sql = "Select * from sort_ s where s.parentId = ?";try{System.out.println("sql:"+sql);list = (List<SortBean>)jdbcDao.queryBeanList(sql, SortBean.class, parentId);//每次查询出上级为的分类System.out.println(list.size());if(list != null && list.size() > 0){for(int i=0;i<list.size();i++){bean = (SortBean)list.get(i);bean.setLevel(level+1); //添加等级字段sortList.add(bean);getSortList(sortList,bean.getSortId(),level+1); //递归查询}}else{level--;}}catch(Exception e){e.printStackTrace();}}测试类：p ublic void test_getSortList() {SortService service = (SortService)beanFactory.getBean("sortService");List<SortBean> sortList = new ArrayList<SortBean>();service.getSortList(sortList, 0L, 0); //起始根节点id为0，等级为0for(SortBean bean: sortList){String str = "";for(int i=0;i<bean.getLevel();i++){str +="——";}System.out.println(str+bean.getSortId() + " " + bean.getParentId() + " " + bean.getSortName());}}查询结果：1000 0 A类|——1001 1000 A类_1|——1003 1001 A类_1_1|——1002 1000 A类_1|——2003 1002 A类_1_1|——2004 2003 A类_1_1_12000 0 B类|——2001 2000 B类_1|——2002 2001 B类_1_1。

java组织树递归详解全文共四篇示例，供读者参考第一篇示例：Java组织树的递归是一种常见且重要的数据结构操作方法，通过递归算法可以方便地遍历和操作组织结构树。

在实际的项目开发中，经常会遇到需要处理组织结构树的情况，比如公司部门架构、树状菜单等。

本文将详细介绍Java组织树递归的原理、实现方式和应用场景。

一、理解组织树在开始讲述组织树的递归之前，首先需要理解什么是组织树。

组织树是一种树形结构，通常用来表示具有层级关系的数据。

比如一个公司的部门架构，可以用一个树形结构来表示，公司为根节点，各个部门为子节点，部门下还可能有子部门或者员工。

树形结构的特点是每个节点都可以有多个子节点，但只有一个父节点，形成了一种层级结构。

二、递归原理递归是一种编程技术，常用于解决问题时，将问题分解成相同类型的子问题，并对子问题进行求解，最终汇总结果。

在处理组织树时，递归的主要原理是通过递归方法，一层一层地对树的每个节点进行遍历，直到叶子节点为止。

递归方法通常需要递归调用自身，以实现对整个树形结构的遍历和操作。

三、组织树递归实现方式在Java中，可以通过递归方法来实现对组织树的遍历和操作。

下面我们以一个简单的示例来说明如何实现组织树的递归：假设有一个部门实体类Department，包含部门ID、部门名称、父部门ID等属性；```javapublic class Department {private Long id;private String name;private Long parentId;// 省略getter和setter方法}```接下来我们定义一个方法，通过递归方式遍历组织树：```javapublic void traverseDepartmentTree(Department department, List<Department> departmentList) {System.out.println(department.getName());List<Department> children = getChildren(department, departmentList);if(children != null && !children.isEmpty()) {for(Department child : children) {traverseDepartmentTree(child, departmentList);}}}private List<Department> getChildren(Department parent, List<Department> departmentList) {List<Department> children = new ArrayList<>();for(Department department : departmentList) {if(parent.getId().equals(department.getParentId())) {children.add(department);}}return children;}```在上面的示例中，traverseDepartmentTree方法接收一个部门对象和部门列表，首先输出当前部门的名称，然后调用getChildren方法获取当前部门的子部门列表，递归遍历子部门，直到叶子节点。

java组织树递归详解-概述说明以及解释1.引言概述部分的内容可以参考以下写法：1.1 概述在软件开发中，组织树递归是一种常见且重要的数据结构和算法，特别适用于涉及组织结构和层级关系的场景。

组织树递归可以帮助我们有效地组织和管理复杂的数据结构，用于表示组织机构、文件目录、分类层级等多种应用场景。

组织树递归的核心思想是通过递归调用，将复杂的问题分解为相对简单的子问题来解决。

通过定义一个递归函数，在函数内部不断调用自身，不断地将问题规模缩小，直到达到终止条件。

这种分而治之的思想可以大大简化问题的解决过程，并且能够很好地利用计算机的存储和运算能力。

本文将详细介绍组织树递归的概念、原理和在Java语言中的实现方式。

首先，我们将对什么是组织树进行解释，介绍递归的基本概念和特点。

然后，我们将着重讨论在Java语言中如何使用递归来实现组织树。

通过具体的代码示例和实践案例，我们将带领读者深入了解组织树递归的优势和使用注意事项。

通过阅读本文，读者将能够全面了解组织树递归在软件开发中的重要性和应用场景，并且能够灵活运用Java语言的递归特性来解决实际问题。

无论是初学者还是有一定经验的开发者，都能够从本文中收获实用而深入的知识，提升自己的编程能力。

接下来，让我们开始深入探索组织树递归吧！1.2 文章结构本篇文章主要围绕Java组织树递归展开讨论，旨在详细介绍组织树的概念和递归的工作原理，并给出Java中实现递归的方法和技巧。

文章结构安排如下：引言部分概述了文章的主题和目的，为读者提供了对整篇文章的总体认识。

概述部分简要介绍了组织树与递归的关系，并提供了本文的整体结构安排。

正文部分是本文的核心内容，分为三个小节。

2.1小节首先解释了什么是组织树，包括组织树的定义和组织树的应用场景。

2.2小节详细介绍了递归的概念，包括递归的定义、递归的基本原理和递归的优缺点。

2.3小节重点讲解了如何在Java中实现递归，包括递归函数的编写和递归的调用方式。

部门树形结构算法—Java递归实现将查询到的部门列表数据，进⾏⽗⼦节点树形结构排序该功能适⽤需要树形结构的，不仅仅是部门树步骤：1. 查询数据库，获得所有的部门列表2. 调⽤下⾯的实现⽅法⼀、建表语句CREATE TABLE `dept` (`deptId` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键',`name` varchar(32) DEFAULT NULL COMMENT '部门名称',`parentId` bigint(20) DEFAULT NULL COMMENT '⽗级部门ID',PRIMARY KEY (`deptId`)) ENGINE=InnoDB DEFAULT CHARSET=utf8⼆、Java实体类package com.changge.pojo;import java.util.ArrayList;import java.util.List;/*** 部门实体** @author 长歌*/public class Dept {/*** 部门id*/private String deptId;/*** 部门名称*/private String name;/*** ⽗部门id*/private String parentId;/*** ⼦部门*/private List<Dept> children = new ArrayList<>();// get,set等⽅法省略...三、实现⽅法代码/*** 构建前端所需要树结构** @param depts 部门列表* @return 树结构列表*/public List<Dept> buildDeptTree(List<Dept> depts) {List<Dept> deptList = new ArrayList<>();List<String> deptIdList = new ArrayList<>();for (Dept dept : depts) {deptIdList.add(dept.getDeptId());}for (Dept dept : depts) {// 如果是顶级节点，遍历该⽗节点所有⼦节点if (!deptIdList.contains(dept.getParentId())) {recursionFn(depts, dept);deptList.add(dept);}}if (deptList.isEmpty()) {deptList = depts;}return deptList;}/*** 递归列表* 结束条件为所遍历的节点⽆下⼀级节点** @param list 查询获得的所有部门数据* @param dept 顶级节点*/private void recursionFn(List<Dept> list, Dept dept) {// 得到⼦节点列表List<Dept> childList = getChildList(list, dept);dept.setChildren(childList);for (Dept tChild : childList) {// 如果⼦节点有下⼀级节点，得到下⼀级的节点列表if (hasChild(list, tChild)) {recursionFn(list, tChild);}}}/*** 获得该节点的下⼀级⼦节点列表** @param list 查询获得的所有部门数据* @param dept 顶级节点* @return 顶级节点的下⼀级⼦节点列表*/private List<Dept> getChildList(List<Dept> list, Dept dept) {List<Dept> deptList = new ArrayList<>();for(Dept d:list){// 遍历⾮顶级节点，并获得传⼊参数顶级节点的下⼀级⼦节点列表if (d.getParentId() != null && d.getParentId().equals(dept.getDeptId())) { deptList.add(d);}}return deptList;}/*** 判断是否有⼦节点** @param list 节点列表* @param dept 部门节点* @return Boolean*/private boolean hasChild(List<Dept> list, Dept dept) {return getChildList(list, dept).size() > 0;}。

java 递归树结构通用方法摘要：1.递归树结构概述2.递归树结构的实现方法3.递归树结构的应用场景4.总结正文：递归树结构是一种在计算机科学中广泛应用的数据结构，它的特点是节点之间存在递归关系。

递归树结构在很多算法和程序设计中都有体现，比如二叉搜索树、决策树等。

本文将介绍递归树结构的通用方法，并举例说明其在实际应用中的作用。

一、递归树结构概述递归树是一种特殊的树结构，它的每个节点都有两个子节点，这两个子节点之间存在递归关系。

在实际应用中，递归树可以用来表示具有层次关系的数据，如文件系统、数据压缩等。

递归树结构的特点如下：1.每个节点最多有两个子节点；2.节点之间的连接是有向的；3.根节点没有父节点，叶子节点没有子节点；4.节点之间的距离是递增的。

二、递归树结构的实现方法在Java中，可以通过定义一个类来表示递归树节点，并实现相应的递归方法。

以下是一个简单的递归树结构实现示例：```javaclass RecursiveTreeNode {int value;RecursiveTreeNode left;RecursiveTreeNode right;public RecursiveTreeNode(int value) {this.value = value;this.left = null;this.right = null;}public void display() {if (this.left != null) {this.left.display();}System.out.println(this.value);if (this.right != null) {this.right.display();}}public static void main(String[] args) {RecursiveTreeNode root = new RecursiveTreeNode(1);root.left = new RecursiveTreeNode(2);root.right = new RecursiveTreeNode(3);root.left.left = new RecursiveTreeNode(4);root.left.right = new RecursiveTreeNode(5);root.right.left = new RecursiveTreeNode(6);root.right.right = new RecursiveTreeNode(7);root.display();}}```上述代码定义了一个简单的递归树，并实现了display()方法用于展示树的结构。

java递归遍历树形结构数据-回复java递归遍历树形结构数据是一种常见的操作，它在许多应用程序中都得到了广泛的应用。

在这篇文章中，我将详细介绍递归遍历树形结构数据的步骤和原理，并提供一些示例代码来帮助读者更好地理解这个过程。

首先，我们需要了解什么是树形结构数据。

树形结构是一种由节点和边组成的数据结构，它具有一个根节点，根节点下面可以有零个或多个子节点。

子节点又可以作为父节点继续拥有自己的子节点，这样便形成了一个有层次结构的数据模型，类似于现实生活中的家谱树。

在Java中，我们可以使用类或接口来表示树形结构数据。

通常，我们会定义一个节点类，用于表示树中的每个节点，该类包含一个值和一个包含子节点的列表。

此外，我们还可以定义一些辅助方法，用于构建树以及遍历树。

那么，接下来让我们来介绍如何使用递归技术来遍历树形结构数据。

请注意，递归是一种函数调用自身的过程，在处理树形结构数据时，它能够非常方便地实现深度优先搜索的效果。

第一步，我们需要编写一个递归函数来遍历树。

此函数将接收一个节点作为参数，并对该节点进行处理，然后递归调用自身以对节点的子节点进行遍历。

这样，我们就可以通过遍历所有的节点来实现对整个树的遍历。

例如，假设我们需要计算树中所有节点的和。

我们可以定义一个名为`calculateSum`的递归函数，它的输入参数是一个节点。

在函数内部，我们首先对当前节点进行处理，比如将其值添加到总和中。

然后，我们使用一个循环来遍历当前节点的所有子节点，并对每个子节点递归调用`calculateSum`函数。

最后，我们将计算得到的总和作为函数的返回值返回。

下面是一个示例代码，演示了如何使用递归遍历树，并计算树中所有节点的值的总和：javapublic int calculateSum(Node node) {int sum = node.getValue();for (Node child : node.getChildren()) {sum += calculateSum(child);}return sum;}在这个示例中，我们首先将根节点的值加入到总和中。

java递归遍历树形结构数据Java中递归遍历树形结构数据可以使用递归算法来实现。

以下是一个示例代码：public class TreeNode {private int value;private List<TreeNode> children;public TreeNode(int value) {this.value = value;this.children = new ArrayList<>();}public void addChild(TreeNode child) {children.add(child);}public int getValue() {return value;}public List<TreeNode> getChildren() {return children;}}public class TreeTraversal {public static void main(String[] args) {// 创建树形结构数据TreeNode root = new TreeNode(1);TreeNode node2 = new TreeNode(2);TreeNode node3 = new TreeNode(3);TreeNode node4 = new TreeNode(4);TreeNode node5 = new TreeNode(5);TreeNode node6 = new TreeNode(6);root.addChild(node2);root.addChild(node3);node2.addChild(node4);node2.addChild(node5);node3.addChild(node6);// 递归遍历树形结构数据traverse(root);}public static void traverse(TreeNode node) {System.out.println(node.getValue());for (TreeNode child : node.getChildren()) {traverse(child);}}}以上代码中，我们定义了一个TreeNode类来表示树形结构中的节点，每个节点包含一个值和一个子节点列表。

递归算法结合数据库解析java树形结构1、准备表结构及对应的表数据a、表结构：create table TB_TREE(CID NUMBER not null,CNAME VARCHAR2(50),PID NUMBER //⽗节点)b、表数据：insert into tb_tree (CID, CNAME, PID) values (1, '中国', 0);insert into tb_tree (CID, CNAME, PID) values (2, '北京市', 1);insert into tb_tree (CID, CNAME, PID) values (3, '⼴东省', 1);insert into tb_tree (CID, CNAME, PID) values (4, '上海市', 1);insert into tb_tree (CID, CNAME, PID) values (5, '⼴州市', 3);insert into tb_tree (CID, CNAME, PID) values (6, '深圳市', 3);insert into tb_tree (CID, CNAME, PID) values (7, '海珠区', 5);insert into tb_tree (CID, CNAME, PID) values (8, '天河区', 5);insert into tb_tree (CID, CNAME, PID) values (9, '福⽥区', 6);insert into tb_tree (CID, CNAME, PID) values (10, '南⼭区', 6);insert into tb_tree (CID, CNAME, PID) values (11, '密云县', 2);insert into tb_tree (CID, CNAME, PID) values (12, '浦东', 4);2、TreeNode对象，对应tb_treepublic class TreeNode implements Serializable {private Integer cid;private String cname;private Integer pid;private List nodes = new ArrayList();public TreeNode() {}//getter、setter省略}3、测试数据public class TreeNodeTest {@Testpublic void loadTree() throws Exception{System.out.println(JsonUtils.javaToJson(recursiveTree(1)));}/*** 递归算法解析成树形结构** @param cid* @return* @author jiqinlin*/public TreeNode recursiveTree(int cid) {//根据cid获取节点对象(SELECT * FROM tb_tree t WHERE t.cid=?)TreeNode node = personService.getreeNode(cid);//查询cid下的所有⼦节点(SELECT * FROM tb_tree t WHERE t.pid=?)List childTreeNodes = personService.queryTreeNode(cid);//遍历⼦节点for(TreeNode child : childTreeNodes){TreeNode n = recursiveTree(child.getCid()); //递归node.getNodes().add(n);}return node;}}输出的json格式如下：{"cid": 1,"nodes": [{"cid": 2,"nodes": [{"cid": 11,"nodes": [],"cname": "密云县","pid": 2}],"cname": "北京市","pid": 1},{"cid": 3,"nodes": [{"cid": 5,"nodes": [{"cid": 7,"nodes": [],"cname": "海珠区", "pid": 5},{"cid": 8,"nodes": [],"cname": "天河区", "pid": 5}],"cname": "⼴州市","pid": 3},{"cid": 6,"nodes": [{"cid": 9,"nodes": [],"cname": "福⽥区", "pid": 6},{"cid": 10,"nodes": [],"cname": "南⼭区", "pid": 6}],"cname": "深圳市","pid": 3}],"cname": "⼴东省","pid": 1},{"cid": 4,"nodes": [{"cid": 12,"nodes": [],"cname": "浦东","pid": 4}],"cname": "上海市","pid": 1}],"cname": "中国","pid": 0}。