脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → Java树形结构

Java利用递归实现树形结构的工具类

 更新时间：2023年03月09日 14:48:30   作者：zyqok  
有时候，我们的数据是带有层级的，比如常见的省市区三级联动，就是一层套着一层。而我们在数据库存放数据的时候，往往是列表形式的，这个时候可能就需要递归处理为树形结构了。本文就为大家介绍了Java利用递归实现树形结构的工具类，希望对大家有所帮助

需求描述

有时候，我们的数据是带有层级的，比如常见的省市区三级联动，就是一层套着一层，如下图：

而我们在数据库存放数据的时候，往往是列表形式的，如下图：

那么当我们从数据库查询出来，返回给前端的时候，前端又需要给出树形层级的时候，这个时候可能就需要递归处理为树形结构了，因此下面这个工具或许就可以用得上了。

使用示例

我们按照上面定义一个Place对象，打上工具注解：

  • @TreeKey 标识唯一
  • @TreeParentKey 标识父节点标识
  • @TreeChildren 标识子孙节点集合
@Data
@Data
public class Place {

    @TreeKey
    private String id;

    @TreeParentKey
    private String parentId;

    private String name;

    @TreeChildren
    private List<Place> children;

    public Place(String id, String name, String parentId) {
        this.id = id;
        this.name = name;
        this.parentId = parentId;
    }
}

测试：

public class Test {

    public static void main(String[] args) {
        List<Place> places = new ArrayList<>();
        places.add(new Place("510000", "四川省", "0"));
        places.add(new Place("510100", "成都市", "510000"));
        places.add(new Place("510107", "武侯区", "510100"));
        places.add(new Place("510116", "双流区", "510100"));
        places.add(new Place("511600", "广安市", "510000"));
        places.add(new Place("511603", "前锋区", "511600"));
        places.add(new Place("511621", "岳池县", "511600"));
        List<Place> treeList = TreeUtils.getTree(places, "0");
        System.out.println(JSON.toJSONString(treeList));
    }

}

最终效果：

工具代码

@TreeKey

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface TreeKey {
}

@TreeParentKey

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface TreeParentKey {
}

@TreeChildren

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface TreeChildren {
}

@TreeUtils

package com.csd.utils.tree;

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Objects;

/**
 * 递归求树形工具类
 *
 * @author Yuanqiang.Zhang
 * @since 2023/3/8
 */
public class TreeUtils {

    /**
     * 集合转化为树形
     *
     * @param list             集合
     * @param highestParentKey 最高层父节点值
     * @param <T>              泛型
     * @return 树形
     */
    public static <T> List<T> getTree(List<T> list, Object highestParentKey) {
        if (Objects.isNull(list) || list.isEmpty()) {
            return Collections.emptyList();
        }
        Field key = null;
        Field parentKey = null;
        Field children = null;
        Field[] fields = list.get(0).getClass().getDeclaredFields();
        for (Field field : fields) {
            if (Objects.isNull(key)) {
                TreeKey treeKey = field.getAnnotation(TreeKey.class);
                if (Objects.nonNull(treeKey)) {
                    key = field;
                    continue;
                }
            }
            if (Objects.isNull(parentKey)) {
                TreeParentKey treeParentKey = field.getAnnotation(TreeParentKey.class);
                if (Objects.nonNull(treeParentKey)) {
                    parentKey = field;
                    continue;
                }
            }
            if (Objects.isNull(children)) {
                TreeChildren treeChildren = field.getAnnotation(TreeChildren.class);
                if (Objects.nonNull(treeChildren)) {
                    children = field;
                    continue;
                }
            }
        }
        if (Objects.isNull(key) || Objects.isNull(parentKey) || Objects.isNull(children)) {
            return Collections.emptyList();
        }
        key.setAccessible(true);
        parentKey.setAccessible(true);
        children.setAccessible(true);
        // 获取最高层数据
        List<T> highs = new ArrayList<>();
        try {
            for (T t : list) {
                Object pk = parentKey.get(t);
                if (getString(pk).equals(getString(highestParentKey))) {
                    highs.add(t);
                }
            }
            // 获取最高层子孙节点
            for (T t : highs) {
                setChildren(list, t, key, parentKey, children);
            }
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return highs;
    }

    /**
     * 获取子孙节点
     *
     * @param list      集合
     * @param parent    父节点对象
     * @param key       唯一属性
     * @param parentKey 父唯一属性
     * @param children  节点
     * @param <T>       泛型
     * @return 带有子孙集合的父节点对象
     * @throws IllegalAccessException
     */
    private static <T> T setChildren(List<T> list, T parent, Field key, Field parentKey, Field children) throws IllegalAccessException {
        Object k = key.get(parent);
        List<T> tempList = new ArrayList<>();
        for (T t : list) {
            Object pk = parentKey.get(t);
            if (getString(k).equals(getString(pk))) {
                tempList.add(setChildren(list, t, key, parentKey, children));
            }
        }
        children.set(parent, tempList);
        return parent;
    }

    /**
     * 获取字符串
     *
     * @param o 值
     * @return 字符串
     */
    private static String getString(Object o) {
        return Objects.isNull(o) ? "" : o.toString();
    }

}

以上就是Java利用递归实现树形结构的工具类的详细内容，更多关于Java树形结构的资料请关注脚本之家其它相关文章！

您可能感兴趣的文章:

相关文章

  • java并发编程专题（四）----浅谈（JUC）Lock锁

    java并发编程专题（四）----浅谈（JUC）Lock锁

    这篇文章主要介绍了java并发编程（JUC）Lock锁的相关内容，文中讲解非常细致，代码帮助大家更好的理解和学习，感兴趣的朋友可以了解下
    2020-06-06
  • Java集合教程之Collection实例详解

    Java集合教程之Collection实例详解

    集合，或者叫容器，是一个包含多个元素的对象，下面这篇文章主要给大家介绍了关于Java集合教程之Collection的相关资料，文中通过示例代码介绍的非常详细，需要的朋友可以参考下
    2018-08-08
  • SpringBoot中并发定时任务的实现、动态定时任务的实现（看这一篇就够了）推荐

    SpringBoot中并发定时任务的实现、动态定时任务的实现（看这一篇就够了）推荐

    这篇文章主要介绍了SpringBoot并发定时任务动态定时任务实现，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
    2019-04-04
  • Java多线程的调度_动力节点Java学院整理

    Java多线程的调度_动力节点Java学院整理

    有多个线程，如何控制它们执行的先后次序呢？下文给大家分享四种方法及java多线程调度的实例代码，需要的朋友参考下吧
    2017-05-05
  • Java开发岗位面试被问到嵌套类怎么办

    Java开发岗位面试被问到嵌套类怎么办

    本篇文章主要介绍了深入理解Java嵌套类和内部类，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
    2021-07-07
  • Spring中@Autowired自动注入map详解

    Spring中@Autowired自动注入map详解

    这篇文章主要介绍了Spring中@Autowired自动注入map详解,  spring是支持基于接口实现类的直接注入的,支持注入map,list等集合中,不用做其他的配置,直接注入,需要的朋友可以参考下
    2023-10-10
  • spring中AOP 注解开发示例详解

    spring中AOP 注解开发示例详解

    这篇文章主要介绍了spring中AOP注解开发的相关资料，文中介绍的很详细，需要的朋友可以参考借鉴，下面来一起看看吧。
    2017-02-02
  • 简单了解Java创建线程两种方法

    简单了解Java创建线程两种方法

    这篇文章主要介绍了简单了解Java创建线程两种方法,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
    2020-02-02
  • Java基础之异常处理详解

    Java基础之异常处理详解

    异常可能是在程序执行过程中产生的,也可能是程序中throw主动抛出的。本文主要给大家介绍了Java中异常处理的相关资料,文中通过实例代码介绍的非常详细,需要的朋友可以参考下
    2023-04-04
  • java简单手写版本实现时间轮算法

    java简单手写版本实现时间轮算法

    这篇文章主要为大家详细介绍了java简单手写版本实现时间轮算法，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
    2021-04-04

最新评论