【java】列表与树之间转换分析以及通用工具类封装

已于 2022-01-19 22:31:36 修改
阅读量761 收藏 1
点赞数 1
分类专栏： java 文章标签： java 开发语言 后端 列表 树结构
于 2022-01-18 12:26:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46827107/article/details/122557442
版权

思路：

（1）先获取到所有根节点，把所有除根结点外的节点作为子节点，然后遍历每一个根节点，进行递归构建此根的子节点。

（2）递归时需要确定一个根节点，以及剩余子节点，如果子节点的父id等于根节点的id，那么就将这个节点加到根节点的children列表中，然后以当前节点作为根节点进行递归，检查是否还有子节点。

（3）关键：如何构建节点，这个节点中应该至少包含三个属性 id、parentId、children

1、思路代码实现

【注意】代码中用到了jackson，你完全可以将其替换为fastjson或gson，甚至不用，直接输出。

【注意】Node类中省略了getter与setter，请手动补齐，或用Lombok也可。

【注意】如果想直接拿到最终的封装好的工具类，直接看2.2

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;

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

public class ListToTree {

    public static List<Node> formatTree(List<Node> nodes) {
        List<Node> tree = new ArrayList<>();
        List<Node> children = new ArrayList<>();
        // 1）先获取到所有根节点
        for (Node node : nodes) {
            if (node.getPid() == 0) {
                tree.add(node);
            } else {
                children.add(node);
            }
        }
        // 2）把所有除根结点外的节点作为子节点，然后遍历每一个根节点
        for (Node node : tree) {
            // 3）递归构建此根的子节点
            recur(node, children);
        }
        return tree;
    }

    public static void recur(Node rootNode, List<Node> children) {
        // 1）遍历剩余子节点，找出当前根的子节点
        for (Node node : children) {
            // 2）如果子节点的父id等于根节点的id，那么就将这个节点加到根节点的children列表中
            if (rootNode.getId() == node.getPid()) {
                if (rootNode.getChildren() == null) {
                    rootNode.setChildren(new ArrayList<>());
                }
                rootNode.getChildren().add(node);
                // 3）以当前节点作为根节点进行递归，检查是否还有子节点。
                recur(node, children);
            }
        }
    }

    public static void main(String[] args) throws JsonProcessingException {
        List<Node> nodes = Arrays.asList(
                new Node(1, 0, "类别1"),
                new Node(2, 0, "类别2"),
                new Node(3, 0, "类别3"),
                new Node(4, 1, "类别1-1"),
                new Node(5, 2, "类别2-1"),
                new Node(6, 1, "类别1-2"),
                new Node(7, 6, "类别1-2-1"));

        List<Node> tree = formatTree(nodes);

        ObjectMapper mapper = new ObjectMapper();
        System.out.println(mapper.writeValueAsString(tree));
    }
}

class Node {
    private String name;
    private int id;
    private int pid;
    private List<Node> children;

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

	// TODO: 省略getter 与 setter，请补全 

}

结果:

[
    {
        "name": "节点1", 
        "id": 1, 
        "pid": 0, 
        "children": [
            {
                "name": "节点1-1", 
                "id": 4, 
                "pid": 1, 
                "children": null
            }, 
            {
                "name": "节点1-2", 
                "id": 6, 
                "pid": 1, 
                "children": [
                    {
                        "name": "节点1-2-1", 
                        "id": 7, 
                        "pid": 6, 
                        "children": null
                    }
                ]
            }
        ]
    }, 
    {
        "name": "节点2", 
        "id": 2, 
        "pid": 0, 
        "children": [
            {
                "name": "节点2-1", 
                "id": 5, 
                "pid": 2, 
                "children": null
            }
        ]
    }, 
    {
        "name": "节点3", 
        "id": 3, 
        "pid": 0, 
        "children": null
    }
]

2、工具类封装

2.1 封装基类实现

通过上面的代码可以发现，要构建树，id、parentId、children这三个属性缺一不可，如果要让工具类通用，需要先封装一个基类，所有需要转换的实体需要继承此类，而工具代码的实现也基于这个类。

【注意】id不一定是Long，也可以是int，Integer等任意类型，只要比较即可。

public class BaseTree {

    public Long id;

    public Long parentId;

    public List<BaseTree> children;

}

工具类代码：

package cn.butcher.utils;

import cn.butcher.common.BaseTree;

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

/**
 * @author butcher
 * @description 列表-树 结构转换工具类
 */
public class ListAndTreeConverter {

    /**
     * <p> 列表转树，递归可以构建”无限“层次树 </p>
     * <p>
     * 使用时只需将待转换列表结构<code>List</code>传入，
     * 即可返回树结构<code>List</code>
     * </p>
     *
     * @param list 待转换列表
     * @param <T>  继承自BaseTree的实体
     * @return 树
     */
    public static <T extends BaseTree> List<T> formatTree(List<T> list) {
        List<T> tree = new ArrayList<>();
        List<T> children = new ArrayList<>();

        for (T node : list) {
            // 如果父节点为空，或者等于0，说明此节点为根节点，否则为子节点
            if (node.parentId == null || node.parentId == 0L) {
                tree.add(node);
            } else {
                children.add(node);
            }
        }

        // 分清顶级根节点后，构造每个根节点的子节点
        for (T rootNode : tree) {
            recur(rootNode, children);
        }
        return tree;
    }

    /**
     * <p> 树转列表，无视层级 </p>
     * <p>
     * 使用时只需将待转换树结构<code>List</code>传入，
     * 即可返回列表结构<code>List</code>
     * </p>
     *
     * @param tree 待转换树
     * @param <T>  继承自BaseTree的实体
     * @return 列表
     */
    public static <T extends BaseTree> List<T> formatList(List<T> tree) {
        List<T> list = new ArrayList<>();
        for (T node : tree) {
            list.add(node);
            recur(list, (List<T>) node.children);
            node.children = null;
        }
        // 根据id排序，此步可省
        Collections.sort(list, (a, b) -> (int) (a.id - b.id));
        return list;
    }

    private static <T extends BaseTree> void recur(T rootNode, List<T> children) {
        for (T node : children) {
            if (node.parentId.equals(rootNode.id)) {
                // 说明为此根的子节点
                if (rootNode.children == null) rootNode.children = new ArrayList<>();
                rootNode.children.add(node);
                recur(node, children);
            }
        }
    }

    private static <T extends BaseTree> void recur(List<T> list, List<T> children) {
        for (T node : children) {
            list.add(node);
            if (node.children != null && node.children.size() > 0) {
                recur(list, (List<T>) node.children);
                node.children = null;
            }
        }
    }
}

测试：

package cn.butcher;

import cn.butcher.common.BaseTree;
import cn.butcher.utils.ListAndTreeConverter;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.util.Arrays;
import java.util.List;

public class TestList2Tree {

    public static void main(String[] args) throws JsonProcessingException {
        List<MyNode> nodes = Arrays.asList(
                new MyNode(1L, 0L, "节点1"),
                new MyNode(2L, 0L, "节点2"),
                new MyNode(3L, 1L, "节点1-1"),
                new MyNode(4L, 1L, "节点1-2"),
                new MyNode(5L, 2L, "节点2-1"),
                new MyNode(6L, 0L, "节点3"),
                new MyNode(7L, 3L, "节点1-1-1"));

        ObjectMapper mapper = new ObjectMapper();

        // 为转化之前
        System.out.println(mapper.writeValueAsString(nodes));

        // 列表转树
        nodes = ListAndTreeConverter.formatTree(nodes);
        System.out.println(mapper.writeValueAsString(nodes));

        // 树转列表
        nodes = ListAndTreeConverter.formatList(nodes);
        System.out.println(mapper.writeValueAsString(nodes));
    }
}

class MyNode extends BaseTree {
    // 本类私有属性
    private String name;

    public MyNode(Long id, Long pid, String name) {
        this.id = id;
        this.parentId = pid;
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

结果：

[
    {
        "id": 1, 
        "parentId": 0, 
        "children": [
            {
                "id": 3, 
                "parentId": 1, 
                "children": [
                    {
                        "id": 7, 
                        "parentId": 3, 
                        "children": null, 
                        "name": "节点1-1-1"
                    }
                ], 
                "name": "节点1-1"
            }, 
            {
                "id": 4, 
                "parentId": 1, 
                "children": null, 
                "name": "节点1-2"
            }
        ], 
        "name": "节点1"
    }, 
    {
        "id": 2, 
        "parentId": 0, 
        "children": [
            {
                "id": 5, 
                "parentId": 2, 
                "children": null, 
                "name": "节点2-1"
            }
        ], 
        "name": "节点2"
    }, 
    {
        "id": 6, 
        "parentId": 0, 
        "children": null, 
        "name": "节点3"
    }
]

2.2 使用函数式接口实现

对于上一种方式，你可能也发现了一些问题，就是还得写一个基类去让其他类继承，并且id、parentId都定死了，还是public的，入侵性太大！灵活性太低，假设在不同的场景下，对id要用不同的注解怎么办，public的属性名父子类不能重复。

所以为了解决上面的一些问题，可以使用函数式接口实现：

package cn.butcher.utils;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.function.BiConsumer;
import java.util.function.BiPredicate;
import java.util.function.Function;
import java.util.function.Predicate;

/**
 * @author butcher
 * @date 2022/1/19 17:46
 * @description
 */
public class listAndTreeUtil {

    /**
     * 线性列表转树形列表
     *
     * @param source      数据源
     * @param checkRoot   如何判断是根节点,接收一个参数，当前节点
     * @param checkParent 如何判断是父节点，接收两个参数分别为根节点、当前节点
     * @param getChildren 如何拿到子节点列表
     * @param setChildren 如何设置子节点列表
     * @param <T>         节点类型
     * @return 树形列表
     */
    public static <T> List<T> formatTree(List<T> source, Predicate<T> checkRoot, BiPredicate<T, T> checkParent, Function<T, List<T>> getChildren, BiConsumer<T, List<T>> setChildren) {
        List<T> tree = new ArrayList<>();
        List<T> children = new ArrayList<>();
        for (T node : source) {
            if (checkRoot.test(node)) {
                tree.add(node);
            } else {
                children.add(node);
            }
        }
        for (T root : tree) {
            recur(root, children, checkParent, getChildren, setChildren);
        }
        return tree;
    }

    /**
     * 树形列表转线性列表
     *
     * @param source      数据源
     * @param getChildren 如何拿到子节点列表
     * @param setChildren 如何设置子节点列表
     * @param <T>         节点类型
     * @return 线性列表
     */
    public static <T> List<T> formatList(List<T> source, Function<T, List<T>> getChildren, BiConsumer<T, List<T>> setChildren) {
        List<T> list = new ArrayList<>();
        for (T node : source) {
            list.add(node);
            recur(list, getChildren.apply(node), getChildren, setChildren);
            setChildren.accept(node, null);
        }
        return list;
    }

    private static <T> void recur(T rootNode, List<T> children, BiPredicate<T, T> checkParent, Function<T, List<T>> getChildren, BiConsumer<T, List<T>> setChildren) {
        for (T node : children) {
            if (checkParent.test(rootNode, node)) {
                // 说明为此根的子节点
                List<T> list = getChildren.apply(rootNode);
                if (list == null) list = new ArrayList<>();
                list.add(node);
                setChildren.accept(rootNode, list);
                recur(node, children, checkParent, getChildren, setChildren);
            }
        }
    }

    private static <T> void recur(List<T> list, List<T> children, Function<T, List<T>> getChildren, BiConsumer<T, List<T>> setChildren) {
        if (children == null) return;
        for (T node : children) {
            list.add(node);
            List<T> c = getChildren.apply(node);
            if (c != null && c.size() > 0) {
                recur(list, c, getChildren, setChildren);
                setChildren.accept(node, null);
            }
        }
    }

    public static void main(String[] args) throws JsonProcessingException {
        List<AnyObj> anyObjs = Arrays.asList(
                AnyObj.builder().id(1).pid(0).build(),
                AnyObj.builder().id(2).pid(0).build(),
                AnyObj.builder().id(3).pid(1).build(),
                AnyObj.builder().id(4).pid(2).build(),
                AnyObj.builder().id(5).pid(3).build(),
                AnyObj.builder().id(6).pid(0).build()
        );

        ObjectMapper mapper = new ObjectMapper();

        System.out.println(mapper.writeValueAsString(anyObjs));

        List<AnyObj> formatTree = formatTree(anyObjs, o -> o.getPid() == 0, (r, n) -> r.getId() == n.getPid(), AnyObj::getChildren, AnyObj::setChildren);

        System.out.println(mapper.writeValueAsString(formatTree));

        List<AnyObj> formatList = formatList(formatTree, AnyObj::getChildren, AnyObj::setChildren);
        // 递归后的线性列表并不是有序的，如果对顺序有要求，可以
        Collections.sort(formatList, (a, b) -> a.getId() - b.getId());
        System.out.println(mapper.writeValueAsString(formatList));

    }
}

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
class AnyObj {
    private int id;
    private int pid;
    private List<AnyObj> children;
}

结果：

[
    {
        "id": 1, 
        "pid": 0, 
        "children": [
            {
                "id": 3, 
                "pid": 1, 
                "children": [
                    {
                        "id": 5, 
                        "pid": 3, 
                        "children": null
                    }
                ]
            }
        ]
    }, 
    {
        "id": 2, 
        "pid": 0, 
        "children": [
            {
                "id": 4, 
                "pid": 2, 
                "children": null
            }
        ]
    }, 
    {
        "id": 6, 
        "pid": 0, 
        "children": null
    }
]

3、总结

线性列表转树形列表是我们开发中常见的问题，两种工具类的封装都是基于思路代码实现的，所以理解原理尤为重要，进一步封装也是基于原理来的。

并不推荐使用2.1的方式来实现通用工具类，它并不灵活，反而会给代码加上负担，2.2函数式接口的方式会是更好的选择，前提是你首先要了解java.util,function包下的这些接口。

butcher2000
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java中平铺列表（List）与树形（Tree）结构的互转
m0_48922996的博客
07-16 3226
至此，递归和非递归分别实现listtotree和treetolist已完成，实现比较仓促，有很多细节处未处理好，希望看到的小伙伴及时指出，不胜感激。另外，机智的你，有其它更好的方法，实现转换吗？欢迎留言分享，码海无涯，共同进步。httpshttps。...
JAVA对象以及数据的工具类
03-22
在Java编程语言中，工具类（Utils）是包含各种实用方法的类，这些方法通常用于执行常见的任务，如类型转换、字符串操作、集合处理等。它们使得代码更加简洁且易于维护，因为它们提供了通用功能的封装，避免了重复...
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
wudaiming的博客
07-10 636
JAVA树形结构存储的解析工具
java 树型结构转list
最新发布
轻描时光
05-08 743
/ System.out.println("找到了节点: " + result.value);// System.out.println("未找到节点");// 查找值为5的节点。
用Java把树形数据转成列表，再把列表转成树形数据 From NewBing
qq_43813182的博客
04-28 372
用Java把树形数据转成列表，再把列表转成树形数据 From NewBing
Java中列表与树状对象的相互转换
qq_42216010的博客
07-13 1047
Java中列表与树状对象的相互转换
在java poi导入Excel通用工具类示例详解
08-29
Java POI 导入 Excel 通用工具类示例详解 Java POI 是一个流行的 Java 库，用于读取和写入 Microsoft Office 文件格式，包括 Excel 文件。在本文中，我们将详细介绍如何使用 Java POI 导入 Excel 文件，并将其转换...
工具类_java_开发工具类_
09-30
同时，通过将这些通用功能封装在工具类中，我们可以避免在多个类或模块中重复实现相同的功能，遵循了DRY（Don't Repeat Yourself）原则，提高了代码的可维护性。 在使用这些工具类时，开发者需要注意几点： 1. 对于...
工具类_java工具类_java_
10-04
Java工具类是程序员在开发过程中经常使用的一类代码集合，它们提供了一系列静态方法，用于执行各种通用任务，如字符串操作、集合处理、IO流操作、数学计算等。在这个压缩包中，我们关注的是一个全面的Java工具类，它...
java_poi导入excel通用工具类
09-09
总结，这个“java_poi导入excel通用工具类”结合了Apache POI的强大功能，Java的反射机制，以及自定义注解的灵活性，为Java开发者提供了一种高效、可定制的Excel数据导入解决方案。通过这样的工具类，我们可以轻松地...
List和tree相互转换
01-19
java中List结构与tree结构相互转化。可实现list转树与tree转list。本链接为解读https://jingyan.baidu.com/article/455a99507b687da1662778ec.html。
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代码实现树节点和列表之间的相互转换
Funny_Ma的博客
07-06 590
Java代码实现树节点和列表之间的相互转换
利用Java8新特性根据id,pid获取树形结构
charismaless的博客
06-30 2152
实体类 @Data @JsonInclude(JsonInclude.Include.NON_NULL) public class SysPermission { private Integer id; private Integer pid; private List<SysPermission> children; } 形成树形结构最关键的是id和pid,其他属性不关键,可以自行定义. 关键代码 // ...上面是获取List<SysPermission&
根据id，pid生成树结构
w_w1314520的博客
08-23 584
【代码】根据id，pid生成树结构。
layui树形菜单写的树形列表（treetable）
热门推荐
Majker的专栏
08-26 3万+
基于layui v2.2.5的 layui-tree写了一个treetable（树形列表） 效果 1.1 收起效果图 1.2 展开效果图 1.开发预备 首先需要到layui官网https://www.layui.com/, 下载layui插件，在页面引入layui.js和layui.css 2.页面元素 &amp;amp;amp;amp;lt;div class=&amp;amp;amp;quot;&a
ztree树与列表名字获取
静待花开
11-09 677
需求： 点击树的某个节点，在节点下增加用户或者部门，要求点击树节点后，树的名字被列表自动获取，不需要手动去输入。 代码： public String FormPage(Model model, HttpServletRequest request) { String parentId = request.getParameter("parentId"); ...
java-树形结构的list，转化为树形结构
努力向上的小姑娘的博客
11-29 5322
举例部门级别 //部门类 public class DeptScopeMode { /** /部门id 如果管理范围是全公司改值为-1 */ private String id; /** /部门名称 */ private String name; /** 上级部门id(用户中心数据权限返回的上级部门id) */ private String parentid; /** 上级部门id...
Java工具类详解： CommonsLang实用组件与功能
1. **org.apache.commons.lang** 包含通用的工具类，如字符串处理、数值转换、类型检查等。这些类如`StringUtils`, `NumberUtils`等提供了便捷的方法，避免了重复编写基础操作的代码。 2. **org.apache.commons....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值