java中把一个list转tree的方法

已于 2023-08-19 23:54:26 修改
阅读量1.6k 收藏 7
点赞数 3
文章标签： java list 开发语言
于 2023-08-19 22:58:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_2662385590/article/details/132384419
版权
文章讨论了如何在数据库中设计存储无限级联树结构的数据表，如菜单、目录或地区，并提供了三种方法将查询结果转化为树形结构：递归、两层循环和两次遍历。作者分析了不同方法的时间和空间复杂度，推荐第三种方法作为最优解。
摘要由CSDN通过智能技术生成

环境

我们有个需求，数据库要存一个无限级联的tree，比如菜单，目录，或者地区等数据，现有两个问题：

  1. 问如何设计表。
  2. 怎么返回给前端一个无线级联的json数据。

思考

第一个问题

在设计表的时候，我们保证每一条数据都有一个code，和parent表示code即可，就可以连成树tree。表设计如下：

CREATE TABLE `city_info`  (
  `code` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '行政区划代码',
  `name` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '名称',
  `type` char(1) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL COMMENT '类型:1-省;2-市;3-县/区',
  `short_name` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL COMMENT '简称',
  `parent` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '所属行政区划',
  `parents` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL COMMENT '所属行政区划分级'
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = '中国省市区县行政区域表' ROW_FORMAT = Dynamic;

第二个问题

我的想法是通过一个sql查询查出来所有数据，得到一个 list集合，然后就回到了主题，如何用java把list转tree。

准备环境

创建一个城市信息类

/**
 * 中国省市区县行政区域表
 * @TableName tbl_city_info
 */
@TableName(value ="tbl_city_info")
@Data
public class CityInfo implements Serializable {
    /**
     * 主键id
     */
    @TableId(value = "id", type = IdType.AUTO)
    private Long id;

    /**
     * 行政区划代码
     */
    @TableField(value = "code")
    private String code;

    /**
     * 名称
     */
    @TableField(value = "name")
    private String name;

    /**
     * 类型:1-省;2-市;3-县/区
     */
    @TableField(value = "type")
    private String type;

    /**
     * 简称
     */
    @TableField(value = "short_name")
    private String shortName;

    /**
     * 所属行政区划
     */
    @TableField(value = "parent")
    private String parent;

    /**
     * 所属行政区划分级
     */
    @TableField(value = "parents")
    private String parents;

    /**
     * 所属行政区划分级
     * Mybatis-plus 映射字段时忽略字段
     */
    @TableField(exist = false)
    private List<CityInfo> childCityInfo;

    @TableField(exist = false)
    private static final long serialVersionUID = 1L;
}

创建一个list转成tree的工具类：

public class TreeUtils{
    public static List<CityInfo> buildTree1(List<CityInfo> cityInfos) {
        // TODO : 第一种解法
        return null;
    }
    public static List<CityInfo> buildTree2(List<CityInfo> cityInfos) {
        // TODO : 第二种解法
        return null;
    }
    public static List<CityInfo> buildTree3(List<CityInfo> cityInfos) {
        // TODO : 第三种解法
        return null;
    }
}

第一种方法：递归

/**
     * 使用递归的方式
     * @param cityInfos 所有的数据
     * @return
     */
    public List<CityInfo> buildTree1(List<CityInfo> cityInfos) {
        List<CityInfo> cityInfoList = new ArrayList<>(16);
        for (CityInfo cityInfo : cityInfos) {
            //找到根集合
            if (cityInfo.getParent().equals("0")) {
                cityInfoList.add(cityInfo);
                //添加子
                setChildren(cityInfos,cityInfo);
            }
        }
        return cityInfoList;
    }

    /**
     * 在所有集合数据中，找到所有的子结果
     * @param cityInfos 所以的数据
     * @param parent    需要找的这个城市的所有的子数据
     */
    public void setChildren(List<CityInfo> cityInfos, CityInfo parent) {

        for (CityInfo cityInfo : cityInfos) {
            List<CityInfo> childCityInfo = parent.getChildCityInfo();
            //如果数据和要找的数据code和parent相等，说明找到了
            if (cityInfo.getParent().equals(parent.getCode())) {
                //如果是第一次，子结果是null，需要赋值一个空数组
                if (CollectionUtils.isEmpty(childCityInfo)) {
                    childCityInfo = new ArrayList<>(16);
                }
                childCityInfo.add(cityInfo);
                parent.setChildCityInfo(childCityInfo);
            }
        }
        //如果上面遍历完了，而且子数据还是空，说明没有子数据，直接返回
        if (CollectionUtils.isEmpty(parent.getChildCityInfo())) {
            return;
        }
        //如果有子数据，需要找子数据，是否有子数据（就是找儿子的儿子）一直递归下去就行了
        for (CityInfo cityInfo : parent.getChildCityInfo()) {
            setChildren(cityInfos,cityInfo);
        }
    }

第二种方法：两层循环

 /**
     * 第二种方法：两层循环
     *      第一层遍历，是为找所有的根节点，
     *      第二层遍历，是为了找所有节点的，子节点
     *      
     *      这里只是返回所有的根节点，因为所有的节点的子节点都找到了，所以只要返回根节点，子节点自己就带上了
     * @param cityInfos 所有的数据
     * @return
     */
    public List<CityInfo> buildTree2(List<CityInfo> cityInfos) {
        List<CityInfo> cityInfoList = new ArrayList<>(16);
        for (CityInfo cityInfo : cityInfos) {
            //找到根集合
            if (cityInfo.getParent().equals("0")) {
                cityInfoList.add(cityInfo);
            }
            //找到本次遍历的节点的，所有子节点（这里子节点就是一层）
            for (CityInfo child : cityInfos) {
                if (cityInfo.getCode().equals(child.getParent())) {
                    List<CityInfo> childCityInfo = cityInfo.getChildCityInfo();
                    if (CollectionUtils.isEmpty(childCityInfo)) {
                        childCityInfo = new ArrayList<>(16);
                        cityInfo.setChildCityInfo(childCityInfo);
                    }
                    childCityInfo.add(child);
                }
            }
        }
        return cityInfoList;
    }

第三种方法：两次遍历

/**
     * 第三种方法：两层循环
     *      第一层遍历，是为了找到所有父code下面的所有的子节点
     *      第二层遍历，是为了给所有的节点，设置子节点，并且找到所有根节点
     * @param cityInfos 所有的数据
     * @return
     */
    public List<CityInfo> buildTree3(List<CityInfo> cityInfos) {
        Map<String, List<CityInfo>> cityInfoParentMap = new HashMap<>(16);

        //本次循环，是为了找到所有父code下面的所有的子节点
        for (CityInfo cityInfo : cityInfos) {
            String parent = cityInfo.getParent();
            List<CityInfo> children = cityInfoParentMap.getOrDefault(parent, new ArrayList<>());
            children.add(cityInfo);
            cityInfoParentMap.put(parent, children);
        }
        List<CityInfo> result = new ArrayList<>(16);
        //在次循环，是为了给所有的节点，设置子节点
//        for (CityInfo cityInfo : cityInfos) {
//            cityInfo.setChildCityInfo(cityInfoParentMap.get(cityInfo.getCode()));
//        }
//        //最好一次循环，是为了找到所有的根节点
//        for (CityInfo cityInfo : cityInfos) {
//            if (cityInfo.getParent().equals("0")) {
//                result.add(cityInfo);
//            }
//        }
        //第二次和第三次，可以合成一次循环
        for (CityInfo cityInfo : cityInfos) {
            cityInfo.setChildCityInfo(cityInfoParentMap.get(cityInfo.getCode()));
            if (cityInfo.getParent().equals("0")) {
                result.add(cityInfo);
            }
        }
        return result;
    }

第三种方法：两次遍历（使用Java8stream流）

  /**
     * 第三种方法：两层循环
     *      第一层遍历，是为了找到所有父code下面的所有的子节点
     *      第二层遍历，是为了给所有的节点，设置子节点，并且找到所有根节点
     * @param cityInfos 所有的数据
     * @return
     */
    public List<CityInfo> buildTree3_stream(List<CityInfo> cityInfos) {
        //本次循环，是为了找到所有父code下面的所有的子节点
        Map<String, List<CityInfo>> cityInfoParenMap = cityInfos.stream().collect(Collectors.groupingBy(CityInfo::getParent));
        //本次循环，是为了给所有的节点，设置子节点
        cityInfos.forEach(cityInfo -> cityInfo.setChildCityInfo(cityInfoParenMap.get(cityInfo.getCode())));
        //是为了找到所有的根节点
        return cityInfos.stream().filter(cityInfo -> cityInfo.getParent().equals("0")).collect(Collectors.toList());
    }

注意：Collectors.groupingBy()方法使用。查看此链接：https://blog.csdn.net/qq_2662385590/article/details/132385605?spm=1001.2014.3001.5502

三种方法对比

前两种方法的时间复杂度都和叶子节点的个数相关，我们假设叶子节点个数为m

  • 方法一: 用递归的方法，时间复杂度等于：O(n +（n-m）*
    n)，根据初始算法那篇文章的计算时间复杂度的方法，可以得到最终时间复杂度是O(n2)
  • 方法二: 用两层嵌套循环的方法，时间复杂度等于：O(n +（n-m）* n)，和方法一的时间复杂度是一样的，最终时间复杂度是O(n2)
  • 方法三:用两次遍历的方法，时间复杂度等于：O(3n)，根据初始算法那篇文章的计算时间复杂度的方法，可以得到最终时间复杂度是O(n)，但它的空间复杂度比前两种方法稍微大了一点，但是也是线性阶的，所以影响不是特别大。
  • 所以第三种方法是个人觉得比较优的一种方法
方法代码执行次数时间复杂度代码复杂程度
方法1O(n +（n-m）* n)平方阶,O(n2)一般
方法2O(n +（n-m）* n)平方阶,O(n2)良好
方法3O(3n)线性阶,O(n)复杂
百事皆可乐~
关注
  • 3
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
java中把一个list转tree的三种方法
01-20
说到java把list转tree，网上有一大堆文章，但是我看过之后发现基本都只说了递归和两层嵌套循环两种方法，没人提到两次遍历的方法，我今天就把三种方法都实现以下，做一下对比 问题 周二面试中，面试官提了一个问题，...
list转树状结构通用工具类
03-21
2. **工具类**：创建TreeUtil类，提供`listToTree(List)`方法，接收一个Node列表，返回转换后的树结构。 ```java public class TreeUtil { public static List<TreeNode> listToTree(List<TreeNode> nodeList) { ...
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把List集合转成树形结构
liyh722的博客
02-21 2080
Java把List集合转成树形结构
JAVA将List转成Tree树形结构数据和深度优先遍历
最新发布
weixin_45817985的博客
06-27 471
JAVA将List转成Tree树形结构数据和深度优先遍历
Java将List转树形结构
luoyueliushuang的博客
01-17 5136
List转树形结构
Java list转tree
人生有梦，未来可期
04-10 287
一、数据模型 @Setter @Getter class Tree { private Integer pid; private Integer id; private Boolean isLeaf = false; private List<Tree> children; public Tree(Integer pid, Integer id...
java list 转树 tree
weixin_41905537的博客
09-19 383
在做目录树的时候通常是将一个目录存在数据库的List全部返回来，再根据节点id和parentId组装成一颗树。 List转成Tree有两种方式，一种是常用的递归，一种是双层循环。(建议递归) package com.gysoft.utils.tree; import lombok.Data; import lombok.ToString; import java.util.List...
List和tree相互转换
01-19
java中List结构与tree结构相互转化。可实现list转树与tree转list。本链接为解读https://jingyan.baidu.com/article/455a99507b687da1662778ec.html。
java8 streamList转换使用详解
08-18
这是一个基于传统循环的方法，使用 `TreeMap` 以保持字母顺序。 ```java public static void letterCount1(String s) { s = s.replaceAll(" +", ""); char c[] = s.toCharArray(); Map, Integer> tree = new ...
JAVA将List转为Tree树结构
weixin_45399695的博客
06-26 2169
JAVA将List转为Tree树结构
java List转tree
weixin_42502300的博客
05-24 60
1、数据库实体类： import com.baomidou.mybatisplus.annotation.IdType; import com.baomidou.mybatisplus.annotation.TableId; import io.swagger.annotations.ApiModel; import io.swagger.annotations.ApiModelProperty; import lombok.Data; import java.util.ArrayList; im
【java】list转tree树型结构
阿来小同学的博客
12-01 461
核心方法: /** * list转tree * @param list 待转的list * @param pid 顶级pid * @return 树型结构数据 */ private static List<DTO> getTree(List<DTO> list, String pid) { List<DTO> rootList = new ArrayList<>();
java list列表转tree树
qq_24902851的博客
04-24 257
具有上下级关系的列表转化成树。
java list转树
毅呀毅呀哟
10-16 252
/** * 循环转换 * @param personList * @return */ public static List<Person> listtotree(List<Person> personList){ List<Person> list = new ArrayList<Pers...
java--list转树形结构
qq_43399762的博客
12-22 2183
【代码】java--list转树形结构。
Java 列表转树状结构 list to tree
瑾年的博客
10-12 3211
利用 stream 实现 List 转树状结构
Java将List列表转换为Tree树结构的方法
sg_knight的专栏
12-15 2571
本文介绍如何从数据库中读取List列表数据并将其转换为Tree树结构数据。从而可以完整展现其中的层级关系。
java实现List结构转Tree型结构
sdgames的博客
10-02 156
我们在做开发的时候，有时候经常用到树形结构，但是我们从数据库取出来的时候是一个List数据对象，其实这个list对象也可以返回给前端去处理成树形结构，但是有个问题，如果数据量大的话，那么前端处理起来的性能就会降低，我举个真实场景，楼主在做电商商品模块的时候，遇到 ...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值