java list集合转数组_java递归查询树形结构

Java (1) 2024-06-04 21:23

Hi,大家好,我是编程小6,很荣幸遇见你,我把这些年在开发过程中遇到的问题或想法写出来,今天说一说java list集合转数组_java递归查询树形结构,希望能够帮助你!!!。

此版本太累赘,请转到函数版:Java集合List转树结构工具类

业务场景:菜单树、组织架构树.....前端要求数据结构为树结构,而后端查出来的是一条一条的数据集,每次都要各种递归遍历很麻烦,特此写了一个工具类来解决.

  • 三个注解:
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @author sunziwen
 * @since 2021-4-13 16:19:05
 */
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface TreeId {
}
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @author sunziwen
 * @since 2021-4-13 16:19:05
 */
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface TreeParentId {
}
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @author sunziwen
 * @since 2021-4-13 16:19:05
 */
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface TreeChildren {
}

一个工具类:

 

import cn.hutool.core.util.StrUtil;
import lombok.SneakyThrows;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 树形工具类
 *
 * @author sunziwen
 * @since 2021-4-13 16:19:05
 */

public class TreeUtil {
    /**
     * 找出顶层节点
     *
     * @return data
     */
    @SneakyThrows
    private <T> List<T> treeOut(List<T> list) {
        //数据不能为空
        if (list == null || list.size() <= 0) {
            return list;
        }
        //获取泛型T的class
        Class<?> aClass = list.get(0).getClass();

        Field[] declaredFields = aClass.getDeclaredFields();
        //获取主键属性
        List<Field> idPropertyField = Arrays.stream(declaredFields).filter(x -> {
            TreeId annotation = x.getAnnotation(TreeId.class);
            return annotation != null;
        }).collect(Collectors.toList());
        if (idPropertyField.size() <= 0) {
            throw new RuntimeException("缺失@TreeId注解");
        }
        if (idPropertyField.size() > 1) {
            throw new RuntimeException("@TreeId注解只能存在一个");
        }
        //获取父节点属性
        List<Field> parentIdPropertyField = Arrays.stream(declaredFields).filter(x -> {
            TreeParentId annotation = x.getAnnotation(TreeParentId.class);
            return annotation != null;
        }).collect(Collectors.toList());
        if (parentIdPropertyField.size() <= 0) {
            throw new RuntimeException("缺失@ParentId注解");
        }
        if (parentIdPropertyField.size() > 1) {
            throw new RuntimeException("@ParentId注解只能存在一个");
        }

        /*主键的属性名*/
        String idPropertyName = idPropertyField.get(0).getName();
        /*主键的get方法*/
        Method getId = aClass.getMethod("get" + StrUtil.upperFirst(idPropertyName));

        /*父节点的属性名*/
        String parentIdPropertyName = parentIdPropertyField.get(0).getName();
        /*父节点的get方法*/
        Method getParentId = aClass.getMethod("get" + StrUtil.upperFirst(parentIdPropertyName));

        /*所有元素的Id*/
        List<Object> ids = list.stream().map(x -> {
            try {
                return getId.invoke(x);
            } catch (IllegalAccessException | InvocationTargetException e) {
                e.printStackTrace();
            }
            return null;
        }).collect(Collectors.toList());
        /*查出所有顶级节点*/
        List<T> topLevel = list.stream().filter(x -> {
            try {
                return !ids.contains(getParentId.invoke(x));
            } catch (IllegalAccessException | InvocationTargetException e) {
                e.printStackTrace();
            }
            return false;
        }).collect(Collectors.toList());

        return recursion(topLevel, list);
    }


    /**
     * 递归装载
     *
     * @param superLevel 上级节点
     * @param list       数据集
     * @return
     */
    @SneakyThrows
    private <T> List<T> recursion(List<T> superLevel, List<T> list) {
        //获取泛型T的class
        Class<?> aClass = list.get(0).getClass();

        Field[] declaredFields = aClass.getDeclaredFields();
        //获取主键属性
        List<Field> idPropertyField = Arrays.stream(declaredFields).filter(x -> {
            TreeId annotation = x.getAnnotation(TreeId.class);
            return annotation != null;
        }).collect(Collectors.toList());
        if (idPropertyField.size() <= 0) {
            throw new RuntimeException("缺失@TreeId注解");
        }
        if (idPropertyField.size() > 1) {
            throw new RuntimeException("@TreeId注解只能存在一个");
        }
        //获取父节点属性
        List<Field> parentIdPropertyField = Arrays.stream(declaredFields).filter(x -> {
            TreeParentId annotation = x.getAnnotation(TreeParentId.class);
            return annotation != null;
        }).collect(Collectors.toList());
        if (parentIdPropertyField.size() <= 0) {
            throw new RuntimeException("缺失@ParentId注解");
        }
        if (parentIdPropertyField.size() > 1) {
            throw new RuntimeException("@ParentId注解只能存在一个");
        }

        //获取父节点属性
        List<Field> childrenPropertyField = Arrays.stream(declaredFields).filter(x -> {
            TreeChildren annotation = x.getAnnotation(TreeChildren.class);
            return annotation != null;
        }).collect(Collectors.toList());
        if (childrenPropertyField.size() <= 0) {
            throw new RuntimeException("缺失@TreeChildren注解");
        }
        if (childrenPropertyField.size() > 1) {
            throw new RuntimeException("@TreeChildren注解只能存在一个");
        }

        /*主键的属性名*/
        String idPropertyName = idPropertyField.get(0).getName();
        /*主键的get方法*/
        Method getId = aClass.getMethod("get" + StrUtil.upperFirst(idPropertyName));

        /*父节点的属性名*/
        String parentIdPropertyName = parentIdPropertyField.get(0).getName();
        /*父节点的get方法*/
        Method getParentId = aClass.getMethod("get" + StrUtil.upperFirst(parentIdPropertyName));

        /*子节点的属性名*/
        String childrenPropertyName = childrenPropertyField.get(0).getName();
        /*字节点的set方法*/
        Method setChildren = aClass.getMethod("set" + StrUtil.upperFirst(childrenPropertyName));


        for (T t : superLevel) {
            List<T> children = list.stream().filter(x -> {
                try {
                    return getParentId.invoke(x).equals(getId.invoke(t));
                } catch (IllegalAccessException | InvocationTargetException e) {
                    e.printStackTrace();
                }
                return false;
            }).collect(Collectors.toList());
            if (children.size() <= 0) {
                continue;
            }
            List<T> recursion = recursion(children, list);
            setChildren.invoke(t, recursion);
        }
        return superLevel;
    }
}
  • 使用示例:
  • 
    import lombok.Data;
    
    import java.util.List;
    
    @Data
    public class My {
        @TreeId//在实体类的主键上打上该注解
        private String id;
    
        @TreeParentId//在实体类的父节点id上打上该注解
        private String parentId;
    
        private String name;
    
        @TreeChildren //在子集上打上该注解
        //@TableField(exist = false)//如果你用的是mybatis-plus则需要让框架忽略该字段
        private List<My> children;
    
        public My(String id, String parentId, String name) {
            this.id = id;
            this.parentId = parentId;
            this.name = name;
        }
    }
        public static void main(String[] args) {
            ArrayList<My> mies = new ArrayList<>();
            mies.add(new My("1", "-1", "a"));
            mies.add(new My("2", "-1", "aa"));
            mies.add(new My("3", "1", "b"));
            mies.add(new My("4", "1", "c"));
            mies.add(new My("5", "3", "d"));
            mies.add(new My("6", "5", "e"));
            mies.add(new My("7", "6", "f"));
            mies.add(new My("8", "2", "g"));
            mies.add(new My("9", "8", "h"));
            mies.add(new My("10", "9", "i"));
            List<My> mies1 = TreeUtil.treeOut(mies);
            System.out.println(mies1);
        }

    大功告成了,如果有问题请加博主V:sunziwen3366

今天的分享到此就结束了,感谢您的阅读,如果确实帮到您,您可以动动手指转发给其他人。

下一篇

已是最新文章

发表回复