java高效率list转tree

最新推荐文章于 2024-05-16 19:20:35 发布
最新推荐文章于 2024-05-16 19:20:35 发布
阅读量2.4k 收藏 15
点赞数
分类专栏： java # 工具类 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010786467/article/details/107609624
版权

java高效率list转tree

最近写的项目里有list转tree需求，之前也写过。所以写下来给大家参考，避免重复造轮子。
网上有很多关于list转tree的文章，但是有很多效率很低，每次都要循环整个list。如果数据量大的话会特别慢（我们公司组织架构，大概有几千条数据，转化为tree明显就很慢），用我下面的方法瞬间就能转化完成。
话不多说上代码：

<!-- pom我引用了lombok，省去了get，set。如果不引用的话，TreeNode需要写get，set方法 -->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.12</version>
</dependency>

TreeNote 类，这里只有核心属性，您实际使用时可根据需求添加属性

import lombok.Data;
import java.util.List;

/**
 * @author 陈飞 (chenfei_kd@qq.com)
 * @version v1.0
 * @since 2020/7/27 11:04
 */
@Data
public class TreeNode {
    private Integer id;
    private Integer pid;
    private String name;
    private List<TreeNode> children;

    public TreeNode() {
    }

    public TreeNode(Integer id, Integer pid, String name) {
        this.id = id;
        this.pid = pid;
        this.name = name;
    }
}

注意下面是转化方法了

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author 陈飞 (chenfei_kd@qq.com)
 * @version v1.0
 * @since 2020/7/27 11:11
 */
public class ListToTree {

    public static void main(String[] args) {
        /**
         * 初始化一个list数据，pid=0为根节点
         */
        List<TreeNode> list = new ArrayList<TreeNode>();
        list.add(new TreeNode(1, 0, "1"));
        list.add(new TreeNode(2, 0, "2"));
        list.add(new TreeNode(3, 2, "3"));
        list.add(new TreeNode(4, 3, "4"));
        list.add(new TreeNode(5, 4, "5"));
        list.add(new TreeNode(6, 5, "6"));

        List<TreeNode> tree = toTree(list);
        System.out.println(tree);
    }

    /**
     * 转化树形结构
     * 1、首先把list转成map  pid作为key，List<TreeNode>作为value
     * 2、递归转化Tree结构
     * @param list
     * @return
     */
    public static List<TreeNode> toTree(List<TreeNode> list) {
        Map<Integer, List<TreeNode>> map = new HashMap<Integer, List<TreeNode>>();
        for (TreeNode tn : list) {
            Integer key = tn.getPid();
            if(map.containsKey(key)) {
                map.get(key).add(tn);
            } else {
                List<TreeNode> mapValue = new ArrayList<TreeNode>();
                mapValue.add(tn);
                map.put(tn.getPid(), mapValue);
            }
        }
        List<TreeNode> tree = map.get(0);
        recursionToTree(tree, map);
        return tree;
    }

    /**
     * 递归转化Tree结构
     * @param list，map
     * @param map
     */
    public static void recursionToTree(List<TreeNode> list, Map<Integer, List<TreeNode>> map){
        for(TreeNode tn : list){
            Integer key = tn.getId();
            if(map.containsKey(key)) {
                List<TreeNode> children = map.get(key);
                tn.setChildren(children);
                recursionToTree(children, map);
            }
        }
    }

}

核心代码如上面所写。如果觉得不够灵活，可使用合适的设计模式重新改造。抽象接口，使用泛型，反射等等
如有效率更快的写法，欢迎留言。

升级版本啦
随手写出来的，仅供参考，算是提供个思路，如有更好的写法希望能分享
需求：任意有逻辑关系的list转tree结构
实现：

  1. 对象继承 Treeable类，并实现方法
  2. 实例化 ListToTree类，调用 toTree方法。搞定收工

首先定义两个接口类：

import java.util.List;

/**
 * 节点类继承接口，节点类必须继承此类
 * @author 陈飞 (chenfei_kd@qq.com)
 * @version v1.0
 * @since 2020/7/27 15:40
 */
public interface Treeable<T> {

    /**
     * 获取存入map key
     * @return
     */
    Object getMapKey();

    /**
     * 获取孩子节点的key值
     * @return
     */
    Object getChildrenKey();

    /**
     * 根节点key值
     * @return
     */
    Object getRootKey();

    /**
     * 子节点赋值
     * @param children
     */
    void setChildren(List<T> children);

}

/**
* ListToTree 一个函数式接口
*/
import java.util.List;

public interface ListToTree<T extends Treeable> {
	
	/**
	 * list转化tree结构
	 */
    List<T> toTree(List<T> list);

}

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * list转tree的实现（有两处判断是否为空的，TODO 根据自己的业务自行实现）
 * @author 陈飞 (chenfei_kd@qq.com)
 * @version v1.0
 * @since 2020/7/27 15:07
 */
public class ListToTreeImpl implements ListToTree {

    @Override
    public List toTree(List list) {
        // TODO list 空判断，做处理
        Map<Object, List> map = new HashMap<Object, List>();
        Object rootKye = null;
        for(Object o : list) {
            Treeable t = (Treeable) o;
            Object key = t.getMapKey();
            if(map.containsKey(key)) {
                map.get(key).add(o);
            } else {
                List mapValue = new ArrayList();
                mapValue.add(o);
                map.put(key, mapValue);
            }
            // 获取根节点key值
            if(rootKye == null) {
                rootKye = t.getRootKey();
            }
        }
        List tree = map.get(rootKye);
        recursionToTree(tree, map);
        return tree;
    }

    private void recursionToTree(List list, Map<Object, List> map){
        // TODO list 空判断，做处理
        for(Object o : list){
            Treeable t = (Treeable) o;
            Object key = t.getChildrenKey();
            if(map.containsKey(key)) {
                List children = map.get(key);
                t.setChildren(children);
                recursionToTree(children, map);
            }
        }
    }

}

import lombok.Data;

import java.util.List;

/**
 * 节点类（必须继承Treeable）
 * @author 陈飞 (fei.chen01@ucarinc.com)
 * @version v1.0
 * @since 2020/7/27 11:04
 */
@Data
public class TreeNode implements Treeable {
    private Integer id;
    private Integer pid;
    private String name;
    private List<TreeNode> children;

    public TreeNode() {
    }

    public TreeNode(Integer id, Integer pid, String name) {
        this.id = id;
        this.pid = pid;
        this.name = name;
    }

    @Override
    public Integer getMapKey() {
        return pid;
    }

    @Override
    public Integer getChildrenKey() {
        return id;
    }

    @Override
    public Integer getRootKey() {
        return 0;
    }

    @Override
    public void setChildren(List children) {
        this.children = children;
    }
}

看了这么多，终于可以测试了，运行下面main方法

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

/**
 * @author 陈飞 (chenfei_kd@qq.com)
 * @version v1.0
 * @since 2020/7/27 15:40
 */
public class Demo {

    public static void main(String[] args) {
        /**
         * 初始化一个list数据，pid=0为根节点
         */
        List<TreeNode> list = new ArrayList<TreeNode>();
        list.add(new TreeNode(1, 0, "1"));
        list.add(new TreeNode(2, 0, "2"));
        list.add(new TreeNode(3, 2, "3"));
        list.add(new TreeNode(4, 3, "4"));
        list.add(new TreeNode(5, 4, "5"));
        list.add(new TreeNode(6, 5, "6"));

        ListToTree treeBuilder = new ListToTreeImpl();
        List<TreeNode> tree = treeBuilder.toTree(list);
        System.out.println(tree);
    }

}
chenfei_kd
关注
  • 0
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
list转树形结构工具类
06-11
将list集合转为树形结构的工具类，只遍历两次即可完成，方便快捷，工具类的扩展性虽然不错，但是效率上好像没有阿里的fastjson这个工具快。
LeetCode 剑指 Offer 68 - II. 二叉树的最近公共祖先（DFS）（Java-树）
ySFRaabbcc的博客
10-08 207
题链接：https://leetcode-cn.com/problems/er-cha-shu-de-zui-jin-gong-gong-zu-xian-lcof/ 题描述： 解题思路： 利用 DFS，对每个节点进行左右子节点的遍历，利用变量 res 保存最近公共祖先节点，利用变量 flag 记录当前节点的子树是否有 p 或者 q，在遍历完左右子节点后，如果当前节点是 p 或 q 中的一个，也让 flag 记录（因为一个节点也可以是它自己的祖先）。如果 p 和 q 都在该节点的子树中，且 re
【java解决List对象转为树结构速度慢的问题】
最新发布
yinchoushi8780的博客
05-16 562
java解决List对象转为树结构速度慢的问题
java list 转 树形json 递归效率对比
yzh20170720的博客
12-19 4427
很多人都遇到过树形json字符串问题。 转树形json我第一反应想到的就是用递归。可是递归速度很慢。 下面是递归的写法:  roots:是最终返回的树形list，直接转换成json就行了。list:是普通的list，需要转成树形的list。 public static void getTree(String parentId,List list,List roots){
Java List结构转Tree树形结构_非递归_简单优化版
大哥的博客
06-01 291
Java List结构转Tree树形结构_非递归_简单优化版方法具体实现总结 方法 public interface TreeNode { static <E extends com.domain.TreeNode> List<E> toTreeList(@NonNull Collection<E> source) { if (source.size() < 2) { return new ArrayList<&
这应该是性能最优的数组转树结构方法
wade3po的博客
03-29 1130
前端使用树插件是一个非常常见的使用场景。树插件的数据格式在我使用过的插件都是一样的。 而这个数据格式是由后端组装好返回给前端还是前端自己组装，这个问题在前端和后端也经常拿来撕逼。 大多数情况下后端会组装好，也有一部分前端自己处理，早之前我合作过的一个后端提出了一个观点， 浏览器是每一个用户都有的，服务器是所有用户共同访问的，后端递归遍历组装树数据比前端处理更耗费性能。 那时候我居然无言以对，几十条数据组装成树结构的数据居然能牵扯到服务器性能问题，那这个服务器还能做什么？ 也不是想讨论由前端还是后端处理的问题
Java list如何根据id获取子节点
08-19
Java list根据id获取子节点详解 Java list根据id获取子节点是Java开发中常见的一种操作，特别是在处理树状结构的...Java list根据id获取子节点是Java开发中常见的一种操作，具有简单易行、高效率和灵活性强等优点。
汉化javaAPI1.9
11-09
3. **新的集合工厂方法**：在Java 9中，集合框架如`List`, `Set`, 和 `Map`接口增加了新的工厂方法，例如`of()`, `copyOf()`和`ofUnmodifiable()`，这些方法用于创建不可变的集合实例，简化了代码并提高了安全性。...
java_data_structure
02-18
9. 红黑树（Red-Black Tree）：自平衡二叉查找树，用于实现TreeSet和TreeMap，保证了插入、删除和查找操作的时间复杂度为O(logn)。 10. 并发集合：Java提供了线程安全的集合实现，如CopyOnWriteArrayList、...
Java 编程之数据结构
11-13
Java中，LinkedList类实现了List接口，提供了一种高效插入和删除元素的方式，但在随机访问元素时效率较低。 3. 栈（Stack） 栈是一种后进先出（LIFO）的数据结构，类似于一个堆叠的盘子。Java中的java.util.Stack类...
List集合转树形结构
m0_48420795的博客
08-17 4532
list集合转成树形集合，分别使用foreach方式和stream流方式进行转换
java的List列表转成Tree（树形）结构列表
宝贝企鹅的博客
04-21 756
直接看借鉴博客：https://blog.csdn.net/massivestars/article/details/53911620/ 由于我的业务没有父子级id两个字段，只有一个层级id字段来分层，如一级数据：01，02，03...，二级数据：0101，0102，0103，0201，...，三级数据：010101，010102...等等，但思路是一样的，我用的是两个for循环搞定，如下...
(转)Java List结构转Tree树形结构_非递归
sq_ikk的博客
11-24 421
记录用
java List＜Map＞转为树形结构
mzcan666的博客
09-03 1744
需求 前端需要写一个级联下拉选，希望得到的数据是Json格式的树形结构，而数据库里面能反映树形结构的有一个pid字段，且程序从数据库获取到的数据是一个列表，当前的任务就是将这个列表转化为树形结构 分析 1,通过观察所需的树形结构的数据格式，设计出的返回数据格式如下： [ { ***:*** children:[ {}, {} ] } ,{} ] 2, 这里可以使用递归来实现children的获取，具体分析写在代码里了 代码 import ja
java中把一个list转tree的三种方法
热门推荐
shj
03-21 1万+
说到java把list转tree，网上有一大堆文章，但是我看过之后发现基本都只说了递归和两层嵌套循环两种方法，没人提到两次遍历的方法，我今天就把三种方法都实现以下，做一下对比
JAVA列表转树状结构-列表拼装树状tree,递归，hutool，效率
大漠孤烟
06-11 979
JAVA树状结构返回方式-列表拼装树状结构第一种：自己写个递归拼装第二种：使用hutool第三方类库（其实原理也是递归）两种方式效率问题 第一种：自己写个递归拼装 //定义一个树状结构的类 @Data static class Column{ private Integer id; private String name; private Integer parentId; private List<Column> ch
Java：List转换为Tree的两种算法
Lzc23333的博客
05-18 486
Java：List转换为Tree的两种算法 一、节点接口  采用接口以适配多种具有嵌套结构的数据类型 /* * 节点接口: * E:接口的实现类类型 * T:id的类型 * */ public interface TreeNode<E,T> { // 此节点的Id T getId(); // 此节点的父节点Id T getPId(); // 设置此节点的子节点列表 void setChildren(List<E> treeNod
Java工具类 - 树状结构工具类（List转树形数据）
qq_42131992的博客
06-15 2665
Java 集合转树状数据工具类
java中实现list转tree的两种方式
xinhe96的博客
01-14 3018
Java中将List转为树形的方法使用改变的方式方式一：递归方式二：stream实体类 使用改变的方式 方式一：递归 public static void main(String[] args) { List<Zone> zones = listWithTree1(); System.out.println(zones); } public static List<Zone> listWithTree1() { List&l
java8 list转tree
04-07
抱歉，我可以回答这个问题。Java8中可以使用Stream API和Collectors工具类将List转换成Tree。具体方法可以参考以下代码： ``` public static <T extends TreeNode> List<T> buildTree(List<T> list) { Map<Long, T> map = list.stream().collect(Collectors.toMap(TreeNode::getId, Function.identity())); List<T> treeList = new ArrayList<>(); for (T node : list) { if (node.getParentId() == null || node.getParentId() == 0) { treeList.add(node); continue; } T parent = map.get(node.getParentId()); if (parent != null) { parent.getChildren().add(node); } } return treeList; } ``` 其中TreeNode是一个接口，需要自己实现getId、getParentId和getChildren方法。这段代码会将list转换成树形结构，并返回根节点集合。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值