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

已于 2023-07-06 14:43:33 修改
阅读量4.1k 收藏 13
点赞数 4
文章标签： 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
关注
  • 4
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
JAVA树状List数据转普通List
qq_41683919的博客
05-30 3561
JAVA树状List转普通List
Java中平铺列表（List）与树形（Tree）结构的互转
m0_48922996的博客
07-16 3198
至此，递归和非递归分别实现listtotree和treetolist已完成，实现比较仓促，有很多细节处未处理好，希望看到的小伙伴及时指出，不胜感激。另外，机智的你，有其它更好的方法，实现转换吗？欢迎留言分享，码海无涯，共同进步。httpshttps。...
List和tree相互转换
01-19
java中List结构与tree结构相互转化。可实现list转树与tree转list。本链接为解读https://jingyan.baidu.com/article/455a99507b687da1662778ec.html。
Java递归将List转为树形结构Java递归将List转为树形结构
12-01
Java递归将List转为树形结构 博客地址：https://blog.csdn.net/weixin_38500202/article/details/110456363
java 树型结构转list
最新发布
轻描时光
05-08 671
/ System.out.println("找到了节点: " + result.value);// System.out.println("未找到节点");// 查找值为5的节点。
java treeNode 树转list
z13571836771的博客
08-16 2139
树转list一般转换方式递归；写起来复制；容易出错。这样就可以应用栈的进出规则进行转化（栈先进后出https://baike.baidu.com/item/%E6%A0%88/12808149?fr=aladdin）： public List<TreeNode> node2List(TreeNode node){ //返回结果集 List<TreeNode> result ...
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 树状list转普通list
Arlo_Liao的博客
12-11 483
/** * 树状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 361
用Java把树形数据转成列表，再把列表转成树形数据 From NewBing
Java中列表与树状对象的相互转换
qq_42216010的博客
07-13 1042
Java中列表与树状对象的相互转换
java将list转为树形结构的方法（后台和前台）
01-20
前台： function listToTree(myId,pId,list){ function exists(list, parentId){ for(var i=0; i<list.length; i++){ if (list[i][myId] == parentId) return true; } return false;
Java 将有父子关系的数据转换成树形结构数据
01-07
一、数据库父子结构数据设计  大部分采用 parentId的形式来存储父id，并且只存储父id，祖父Id不存储。也可以添加存储层级级别或者层级关系等字段。 CREATE TABLE `t_resource` ( `id` varchar(255) NOT NULL ...
javascript将扁平的数据转为树形结构的高效率算法
10-15
在JavaScript编程中，将扁平的数据结构转换为树形结构是一项常见的任务，特别是在处理层级关系的数据时，如组织结构、菜单导航或文件系统等。在本文中，我们将深入探讨一种高效的算法，该算法可以将一维数组转换为...
树形结构设计总结java demo
03-04
本篇文章将深入探讨“树形结构设计”在Java环境下的实现，并结合给出的链接资源——一篇在CSDN博客上的文章（虽然无法直接访问，但我们可以根据描述推测其内容），以及名为“tms”的压缩包文件，来解析相关知识点。...
Java list转tree，tree转list(递归实现)
失忆老幺
07-18 7299
下班回家途中的风景。生活不止眼前的苟且，还有到不了的远方和看不见的风景。 实现简易的留言板，list转换成树，树转出成list。 表结构如下 根据不同的场景设计表结构，如果像微信公众号留言那种，可以添加一个文章id。 表中的留言信息 controller层 /** * * @author shiyi * @since 2020-07-16 */ @RestController @RequestMapping("/message") public class MessageControlle.
【Java用法】Hutool树结构工具-TreeUtil快速构建树形结构的两种方式 + 数据排序
No8g攻城狮的博客
12-08 8252
考虑到菜单等需求的普遍性，有用户提交了一个扩展性极好的树状结构实现。这种树状结构可以根据配置文件灵活的定义节点之间的关系，也能很好的兼容关系数据库中数据。实现 关系型数据库数据 Tree JSON 树状结构中最大的问题就是关系问题，在数据库中，每条数据通过某个字段关联自己的父节点，每个业务中这个字段的名字都不同，如何解决这个问题呢？PR的提供者提供了一种解决思路：自定义字段名，节点不再是一个bean，而是一个map，实现灵活的字段名定义。
JAVA的树形结构存储数据提取成List
wudaiming的博客
07-10 624
JAVA树形结构存储的解析工具
java树形结构List和普通结构的List互转
weixin_38278302的博客
12-30 833
本文记录和分享List结构数据转树结构算法
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、付费专栏及课程。

余额充值