java 处理树形结构 树形转为list list转为树形

已于 2023-07-06 14:43:33 修改
阅读量4.2k 收藏 12
点赞数 5
文章标签： java list jvm
于 2022-07-28 18:04:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45860338/article/details/126040120
版权

java 处理树形结构 树形转为list list转为树形


实体类结构： 

@Data
@NoArgsConstructor
@AllArgsConstructor
class Node {
    // id
    private Integer id;
    // 父id
    private Integer pId;
    // 名称
    private String name;
    // 祖级id列表
    private List<Integer> ancestors;
    // 子节点
    private List<Node> children;

    public Node(int id, int pId, String name) {
        this.id = id;
        this.pId = pId;
        this.name = name;
    }

    @Override
    public String toString() {
        return "Node{" +
                "id=" + id +
                ", pId=" + pId +
                ", name='" + name + '\'' +
                ", ancestors=" + ancestors +
                ", children=" + children +
                '}';
    }
}

🍇树形转为list

	@Test
    public void test01() {
        // 填充数据
        Node level4 = new Node(4, 3, "level4-01");
        Node level3 = new Node(3, 2, "level3-01");
        Node level2 = new Node(2, 1, "level2-01");
        Node level22 = new Node(22, 1, "level2-02");
        Node level1 = new Node(1, 0, "level1-01");
        List<Node> level3children = new ArrayList<>();
        level3children.add(level4);
        level3.setChildren(level3children);
        List<Node> level2children = new ArrayList<>();
        level2children.add(level3);
        level2.setChildren(level2children);
        List<Node> children = new ArrayList<>();
        children.add(level2);
        children.add(level22);
        level1.setChildren(children);
        System.out.println(level1.toString());
        System.out.println("===============before===============");
        // 树形转为list
        List<Node> result = new ArrayList<>();
        this.recursionTreeToList(result, level1, null);
        for (Node node : result) {
            node.setChildren(null);
            System.out.println(node.toString());
        }
        System.out.println("===============after===============");
    }
    /**
    
     * 递归把传过来的tree转为list
     *
     * @param result     结果集
     * @param root       当前对象
     * @param parentNode 没有传Null
     */
    public void recursionTreeToList(List<Node> result, Node root, Node parentNode) {
        // 如果没有pid那么就赋值
       /* if (parentNode != null) {
            root.setPid(parentNode.getEid());
        }*/
        result.add(root);
        if (CollectionUtils.isEmpty(root.getChildren())) {
            return;
        }
        for (Node child : root.getChildren()) {
            this.recursionTreeToList(result, child, root);
        }
    }

结果如下：
在这里插入图片描述

🍇每个节点对祖级列表的编号List赋值

	@Test
    public void test01() {
        // 填充数据
        Node level4 = new Node(4, 3, "level4-01");
        Node level3 = new Node(3, 2, "level3-01");
        Node level2 = new Node(2, 1, "level2-01");
        Node level22 = new Node(22, 1, "level2-02");
        Node level1 = new Node(1, 0, "level1-01");
        List<Node> level3children = new ArrayList<>();
        level3children.add(level4);
        level3.setChildren(level3children);
        List<Node> level2children = new ArrayList<>();
        level2children.add(level3);
        level2.setChildren(level2children);
        List<Node> children = new ArrayList<>();
        children.add(level2);
        children.add(level22);
        level1.setChildren(children);
        System.out.println(level1.toString());
        System.out.println("===============before===============");
        // 树形转为list
        List<Node> result = new ArrayList<>();
        this.recursionTreeToList(result, level1, null);
        for (Node node : result) {
            node.setChildren(null);
            System.out.println(node.toString());
        }
        System.out.println("===============after===============");
        // 处理祖父列表
        this.handleAncestors(result);
        for (Node node : result) {
            System.out.println(node.toString());
        }
        System.out.println("===============handle ancestors after===============");
    }

    /**
     * 递归把传过来的tree转为list
     *
     * @param result     结果集
     * @param root       当前对象
     * @param parentNode 没有传Null
     */
    public void recursionTreeToList(List<Node> result, Node root, Node parentNode) {
        // 如果没有pid那么就赋值
       /* if (parentNode != null) {
            root.setPid(parentNode.getEid());
        }*/
        result.add(root);
        if (CollectionUtils.isEmpty(root.getChildren())) {
            return;
        }
        for (Node child : root.getChildren()) {
            this.recursionTreeToList(result, child, root);
        }
    }


    List<Integer> ancestors = new ArrayList<>();

    /**
     * 给list赋值祖父节点
     * @param list
     */
    public void handleAncestors(List<Node> list) {
        for (Node node : list) {
            ancestors = new ArrayList<>();
            List<Integer> ancestorsList = this.recursionAncestors(list, node);
            ancestorsList.add(node.getId());
            node.setAncestors(ancestorsList);
        }
    }

    /**
     * 根据当前节点查询他的祖父列表
     * @param list 数据List
     * @param n 当前节点
     * @return 所有父节点
     */
    public List<Integer> recursionAncestors(List<Node> list, Node n) {
        if (n.getId() == null) {
            return ancestors;
        }
        for (Node node : list) {
            if (n.getPId() == node.getId()) {
                this.recursionAncestors(list, node);
                ancestors.add(node.getId());
            }
        }
        return ancestors;
    }

结果如下：
在这里插入图片描述

🍇list转为树形

方式1

 	@Test
    public void test01() {
        // 填充数据
        Node level4 = new Node(4, 3, "level4-01");
        Node level3 = new Node(3, 2, "level3-01");
        Node level2 = new Node(2, 1, "level2-01");
        Node level22 = new Node(22, 1, "level2-02");
        Node level1 = new Node(1, 0, "level1-01");
        List<Node> level3children = new ArrayList<>();
        level3children.add(level4);
        level3.setChildren(level3children);
        List<Node> level2children = new ArrayList<>();
        level2children.add(level3);
        level2.setChildren(level2children);
        List<Node> children = new ArrayList<>();
        children.add(level2);
        children.add(level22);
        level1.setChildren(children);
        System.out.println(level1.toString());
        System.out.println("=============== before Tree To List ===============");
        List<Node> result = new ArrayList<>();
        // 树形转为list
        this.recursionTreeToList(result, level1, null);
        for (Node node : result) {
            node.setChildren(null);
            System.out.println(node.toString());
        }
        System.out.println("=============== after Tree To List ===============");
        // 处理祖父列表
        this.handleAncestors(result);
        for (Node node : result) {
            System.out.println(node.toString());
        }
        System.out.println("===============handle ancestors after===============");
        List<Node> nodes = this.recursionListToTree(result, 0);
        for (Node node : nodes) {
            System.out.println(node.toString());
        }
        System.out.println("=============== after List To Tree ===============");
    }

    /**
     * 递归把传过来的tree转为list
     *
     * @param result     结果集
     * @param root       当前对象
     * @param parentNode 没有传Null
     */
    public void recursionTreeToList(List<Node> result, Node root, Node parentNode) {
        // 如果没有pid那么就赋值
       /* if (parentNode != null) {
            root.setPid(parentNode.getEid());
        }*/
        result.add(root);
        if (CollectionUtils.isEmpty(root.getChildren())) {
            return;
        }
        for (Node child : root.getChildren()) {
            this.recursionTreeToList(result, child, root);
        }
    }

    /**
     * 递归方法把传过来的list转为tree
     *
     * @param tree     父节点对象
     * @param treeList 所有的List
     * @return
     */
    public List<Node> recursionListToTree(List<Node> list, int pId) {
        List<Node> nodes = new ArrayList<>();
        for (Node node : list) {
            // 找出父节点
            if (pId == node.getPId()) {
                // 调用递归方法填充子节点列表
                nodes.add(this.findChildren(node, list));
            }
        }
        return nodes;
    }

    /**
     * 递归方法
     *
     * @param tree     父节点对象
     * @param treeList 所有的List
     * @return
     */
    public Node findChildren(Node tree, List<Node> treeList) {
        for (Node node : treeList) {
            if (tree.getId().equals(node.getPId())) {
                if (CollectionUtils.isEmpty(tree.getChildren())) {
                    tree.setChildren(new ArrayList<>());
                }
                // 递归 调用自身
                tree.getChildren().add(this.findChildren(node, treeList));
            }
        }
        return tree;
    }

    List<Integer> ancestors = new ArrayList<>();

    /**
     * 给list赋值祖父节点
     *
     * @param list
     */
    public void handleAncestors(List<Node> list) {
        for (Node node : list) {
            ancestors = new ArrayList<>();
            List<Integer> ancestorsList = this.recursionAncestors(list, node);
            ancestorsList.add(node.getId());
            node.setAncestors(ancestorsList);
        }
    }

    /**
     * 根据当前节点查询他的祖父列表
     *
     * @param list 数据List
     * @param n    当前节点
     * @return 所有父节点
     */
    public List<Integer> recursionAncestors(List<Node> list, Node n) {
        if (n.getId() == null) {
            return ancestors;
        }
        for (Node node : list) {
            if (n.getPId() == node.getId()) {
                this.recursionAncestors(list, node);
                ancestors.add(node.getId());
            }
        }
        return ancestors;
    }

结果如图：
在这里插入图片描述

方式2（使用stream，如果id是唯一的话，比递归效率快）

    /**
     * stream把传过来的list转为tree
     * 
     * @param tree     父节点对象
     * @param treeList 所有的List
     * @return
     */
    public List<Node> handleListToTree(List<Node> list, int pId) {
         List<Node> nodes = new ArrayList<>();
		 Map<String, List<Node>> nodeMap = list.stream().collect(Collectors.groupingBy(Node::getPId));
		 list.forEach(n -> { n.setChildren(nodeMap.get(n.getPId())); });
		 nodes = list.stream().filter(n -> n.getPId().equals(pId)).collect(Collectors.toList());
		 return nodes;
    }

方式3（使用插件）

1.导入jar包

<dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>RELEASE</version>
            <scope>test</scope>
        </dependency>
        <!-- https://mvnrepository.com/artifact/junit/junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
<!--   -->
        <!-- liu https://mvnrepository.com/artifact/com.google.guava/guava -->
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>29.0-jre</version>
        </dependency>
    </dependencies>

2.编写代码

import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.Multimap;
import lombok.*;
import org.junit.Test;

import java.util.*;

/**
 * @author: doris
 * @date: 2023/7/6 13:27
 */
public class TestTree {

    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    class Node {
        // id
        private String id;
        // 父id
        private String pId;
        // 名称
        private String name;
        // 祖级id列表 ,
        private String ancestors;
        // 子节点
        private List<Node> children;
    }

    @Test
    public void test01() {
        List<Node> list = new ArrayList<>();
        list.add(new Node("0", "999999", "level", "999999", null));
        list.add(new Node("1", "0", "level1", "999999,0", null));
        list.add(new Node("2", "1", "level2", "999999,0,1", null));
        list.add(new Node("3", "2", "level3", "999999,0,1,2", null));
        System.out.println("======================start======================");
        Multimap<String, Node> myMultimap = ArrayListMultimap.create();
        for (Node node : list) {
            System.out.println(node);
            myMultimap.put(node.getPId(), node);
        }
        Node build = list.get(0);
        Node tree = createTree(build, myMultimap);
        System.out.println(tree);

    }

    /**
     * 创建树形数据
     * @param build 顶点
     * @param myMultimap 树
     * @return
     */
    public Node createTree(Node build, Multimap<String, Node> myMultimap) {
        if (myMultimap.get(build.getId()) != null) {
            List<Node> list = (List<Node>) myMultimap.get(build.getId());
            recursionData(list, myMultimap);
            build.setChildren(list);
        }
        return build;
    }

    public void recursionData(Collection<Node> list, Multimap<String, Node> myMultimap) {
        for (Node node : list) {
            if (myMultimap.get(node.getId()) != null) {
                List<Node> t = (List<Node>) myMultimap.get(node.getId());
                recursionData(t, myMultimap);
                node.setChildren(t);
            }
        }
    }
}

3.结果：
开始数据转换完树形结构

从数据查询树

1.添加数据的时候加入祖父列表字段，方便匹配（推荐）

select * from tb1 where FIND_IN_SET('id',祖父列表字段) > 0

2.Mysql进行树形查询

SELECT DISTINCT tb1.id,  pid 
FROM tb1, ( SELECT @pid := 'id' ) pd 
WHERE
	FIND_IN_SET( pid, @pid ) > 0 
	AND @pid := concat( @pid, ',', id ) 
UNION SELECT id, pid  FROM tb1  WHERE id = 'id ';
dorisPotter
关注
  • 5
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
JAVA树状List数据转普通List
qq_41683919的博客
05-30 3566
JAVA树状List转普通List
Java中平铺列表（List）与树形（Tree）结构的互转
m0_48922996的博客
07-16 3218
至此，递归和非递归分别实现listtotree和treetolist已完成，实现比较仓促，有很多细节处未处理好，希望看到的小伙伴及时指出，不胜感激。另外，机智的你，有其它更好的方法，实现转换吗？欢迎留言分享，码海无涯，共同进步。httpshttps。...
Java 将树转为List
SALT的博客
09-03 1万+
1、需求，将一棵无关联属性的树（没有id和pid）转化为list存储（通过id和pid关联） 2、思路，该处只能通过广度遍历树获取list。如果使用深度遍历的话，pid将获取不到正确的值。 3、树的结构如下。(无id和pid) public class Tree { private String name; private List&lt;Tree&gt; children...
java实现分类下拉树，点击时对应搜索---后端逻辑
最新发布
qq_64595427的博客
06-20 983
一直想做分类下拉，然后选择后搜索的页面，正好做项目有了明确的需求，查找后发现el-tree的构件可满足需求，数据要求为：{ id:1, label:name, childer:[……] }形式的，于是乎，开搞！
java 树状list转普通list
Arlo_Liao的博客
12-11 489
/** * 树状list转普通list * *@param list 树列表 *@return 普通list */ public static List treeToList(List<T> list) { List result = new ArrayList<>(); for(T test : list) { List c = test.getChildren(); result.add(test); .
用Java把树形数据转成列表，再把列表转成树形数据 From NewBing
qq_43813182的博客
04-28 371
用Java把树形数据转成列表，再把列表转成树形数据 From NewBing
java 树型结构转list
轻描时光
05-08 723
/ System.out.println("找到了节点: " + result.value);// System.out.println("未找到节点");// 查找值为5的节点。
Java递归将List转为树形结构Java递归将List转为树形结构
12-01
Java递归将List转为树形结构 博客地址：https://blog.csdn.net/weixin_38500202/article/details/110456363
java将list转为树形结构的方法（后台和前台）
01-20
标题中的“java将list转为树形结构的方法（后台和前台）”指的是在Java编程语言中，如何将一个列表（List）数据结构转换为树形结构。这种转换通常用于处理层级关系的数据，如目录结构、组织架构等。转换分为前端...
Java 将有父子关系的数据转换成树形结构数据
01-07
一、数据库父子结构数据设计  大部分采用 parentId的形式来存储父id，并且只存储父id，祖父Id不存储。也可以添加存储层级级别或者层级关系等字段。 CREATE TABLE `t_resource` ( `id` varchar(255) NOT NULL ...
javascript将扁平的数据转为树形结构的高效率算法
10-15
在JavaScript编程中，将扁平的数据结构转换为树形结构是一项常见的任务，特别是在处理层级关系的数据时，如组织结构、菜单导航或文件系统等。在本文中，我们将深入探讨一种高效的算法，该算法可以将一维数组转换为...
List和tree相互转换
01-19
java中List结构与tree结构相互转化。可实现list转树与tree转list。本链接为解读https://jingyan.baidu.com/article/455a99507b687da1662778ec.html。
树形结构设计总结java demo
03-04
本篇文章将深入探讨“树形结构设计”在Java环境下的实现，并结合给出的链接资源——一篇在CSDN博客上的文章（虽然无法直接访问，但我们可以根据描述推测其内容），以及名为“tms”的压缩包文件，来解析相关知识点。...
Java中列表与树状对象的相互转换
qq_42216010的博客
07-13 1046
Java中列表与树状对象的相互转换
Java代码实现树节点和列表之间的相互转换
Funny_Ma的博客
07-06 589
Java代码实现树节点和列表之间的相互转换
Tree树状结构转list，获取从根节点到叶子节点中，每条路径上的所有集合
佛说"獨" 的博客
03-18 871
Tree对象结构： public class B { private Integer id; private String label; private Integer nodeType; private List<B> children; //关键字段 public Integer getId() { return id; } public void setId(Integer id) { this.id = id; }
【java】列表与树之间转换分析以及通用工具类封装
butcher的博客
01-18 761
思路： （1）先获取到所有根节点，把所有除根结点外的节点作为子节点，然后遍历每一个根节点，进行递归构建此根的子节点。 （2）递归时需要确定一个根节点，以及剩余子节点，如果子节点的父id等于根节点的id，那么就将这个节点加到根节点的children列表中，然后以当前节点作为根节点进行递归，检查是否还有子节点。 （3）关键：如何构建节点，这个节点中应该至少包含三个属性 id、parentId、children
最简便的list数据转树形结构方法（递归详细）
热门推荐
js_admin的博客
05-31 1万+
后台返回数据是一行一行的，但是前端展示要树形结构数据，所以需要我们自己处理函数了，小编在此献丑了，小写一个简便函数供大家参考，希望反馈一下。 返回数据格式 : var list= [ { name: '根目录1', id: 1, parentId: 0 }, { name: '根目录2', id: 2, parentId: 0 }, { name: '目录1-1', id: ...
java-树形结构的list，转化为树形结构
努力向上的小姑娘的博客
11-29 5320
举例部门级别 //部门类 public class DeptScopeMode { /** /部门id 如果管理范围是全公司改值为-1 */ private String id; /** /部门名称 */ private String name; /** 上级部门id(用户中心数据权限返回的上级部门id) */ private String parentid; /** 上级部门id...
java将树形结构转为list
04-26
你可以使用递归的方式来将树形结构转为list。具体来说，你可以先将根节点加入list中，然后递归处理每个子节点，并将它们加入list中。实现代码如下： ```java public List<TreeNode> flatten(TreeNode root) { List<TreeNode> result = new ArrayList<>(); flattenHelper(root, result); return result; } private void flattenHelper(TreeNode node, List<TreeNode> result) { result.add(node); for (TreeNode child : node.getChildren()) { flattenHelper(child, result); } } ``` 这里假设树节点的定义如下： ```java public class TreeNode { private int val; private List<TreeNode> children; public TreeNode(int val) { this.val = val; children = new ArrayList<>(); } public void addChild(TreeNode child) { children.add(child); } public List<TreeNode> getChildren() { return children; } } ``` 如果你希望将树形结构转为list的同时保留节点的层级信息，可以使用一个helper类来记录每个节点的层级： ```java public class FlattenedTreeNode { private TreeNode node; private int level; public FlattenedTreeNode(TreeNode node, int level) { this.node = node; this.level = level; } public TreeNode getNode() { return node; } public int getLevel() { return level; } } public List<FlattenedTreeNode> flatten(TreeNode root) { List<FlattenedTreeNode> result = new ArrayList<>(); flattenHelper(root, 0, result); return result; } private void flattenHelper(TreeNode node, int level, List<FlattenedTreeNode> result) { result.add(new FlattenedTreeNode(node, level)); for (TreeNode child : node.getChildren()) { flattenHelper(child, level + 1, result); } } ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值