java构建树状结构工具类

最新推荐文章于 2025-05-15 17:00:41 发布

原创最新推荐文章于 2025-05-15 17:00:41 发布 · 634 阅读

1 ·

CC 4.0 BY-SA版权

本文介绍了一种树状结构工具类的实现方法，该工具类能够从一组对象中自动分离出根节点和非根节点，并通过递归方式构建完整的树状结构。使用示例展示了如何初始化工具类并获取树状结构。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

树状结构工具
创建类TreeUtil
类属性

private List<T> rootList; //根节点对象存放到这里

private List<T> bodyList; //其他节点存放到这里，可以包含根节点

private Function<T,Object> treeId; //获取子级id接口

private Function<T,Object> treeRootId;//获取上级id接口

private BiConsumer<T,List> treeSetList;//用于setList的接口

两个构造方法

 /**
     *  传入根节点与非根节点,实现三个函数接口
     * @param rootList 根节点
     * @param bodyList  非根节点
     * @param treeId    函数->获取id
     * @param treeRootId    ->获取根id
     * @param treeSetList   ->保存集合方法
     */
    public TreeUtil(List<T> rootList, List<T> bodyList, Function treeId, Function treeRootId, BiConsumer treeSetList) {
        this.rootList = rootList;
        this.bodyList = bodyList;
        this.treeId = treeId;
        this.treeRootId = treeRootId;
        this.treeSetList = treeSetList;
    }

/**
     *传入集合,实现三个函数接口
     * @param salesAreaTrees 集合
     * @param treeId     函数->获取id
     * @param treeRootId    ->获取根id
     * @param treeSetList   ->保存集合方法
     */
    public TreeUtil(List<T> salesAreaTrees, Function treeId, Function treeRootId, BiConsumer treeSetList) {
        this.treeId = treeId;
        this.treeRootId = treeRootId;
        this.treeSetList = treeSetList;
        //调用内部方法分离出根节点与非根节点
        this.getRootList(salesAreaTrees);
    }

分离方法

 /**
     * 得到RootList和BodyList
     *
     * @param list
     */
    private void getRootList(List<T> list) {
        rootList = new ArrayList<>();
        bodyList = new ArrayList<>();
        List<Object> ids = list.stream()
                .parallel()
                .map(p -> this.treeId.apply(p))
                .collect(Collectors.toList());
        List<Object> pids = list.stream()
                .parallel()
                .map(p -> this.treeRootId.apply(p))
                .collect(Collectors.toList());

        //(求id和pid的交集->用于推导非根节点 )
        List<Object> notRootPids = ids.stream()
                .parallel()
                .filter(id -> pids.contains(id))
                .collect(Collectors.toList());


        //非根节点
        rootList=list.stream()
                .parallel()
                .filter(item -> !notRootPids.contains(this.treeRootId.apply(item)))
                .collect(Collectors.toList());
        //通过非根节点->根节点
        bodyList = list.stream()
                .parallel()
                .filter(item -> !rootList.contains(item))
                .collect(Collectors.toList());

    }

递归

public List<T> getTree() {   //调用的方法入口
        if (bodyList != null && !bodyList.isEmpty()) {
            //声明一个map，用来过滤已操作过的数据
            Map<Object, Object> map = Maps.newHashMapWithExpectedSize(bodyList.size());
            rootList.forEach(beanTree -> getChild(beanTree, map));
            return rootList;
        }
        return rootList;
    }

    private void getChild(T t, Map<Object, Object> map) {
        List<T> childList = new ArrayList<>();
        bodyList.stream()
                .filter(c -> !map.containsKey(treeId.apply(c)))
                .filter(c -> Objects.equals(this.treeRootId.apply(c),this.treeId.apply(t)))
                .forEach(c -> {
                    map.put(this.treeId.apply(c), this.treeRootId.apply(c));
                    getChild(c, map);
                    childList.add(c);
                });
        this.treeSetList.accept(t, childList);
    }

到此此工具类构建完毕.
使用示例:
构建函数

List<Tree> list=service.getList;
 Function<Tree,Long> function=Division::getId;
 Function<Tree,Long> function2=Division::getParentId;
 BiConsumer<Tree,List<Division>> treeSetList=Division::setChildList;

构建工具类

 TreeUtil<Tree> treeUtil= new TreeUtil<>(list,function,function2,treeSetList);

调用方法获得树状结构

treeUtil.getTree();

工具类完整代码

import com.google.common.collect.Maps;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.function.BiConsumer;
import java.util.function.Function;
import java.util.stream.Collectors;![在这里插入图片描述](https://img-blog.csdnimg.cn/20190807155602797.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDUyNjQzMw==,size_16,color_FFFFFF,t_70)

/**
 * @author 72060500
 * @version 1.0.1
 * 树状工具类
 */
public class TreeUtil<T> {
    private List<T> rootList; //根节点对象存放到这里

    private List<T> bodyList; //其他节点存放到这里，可以包含根节点

    private Function<T,Object> treeId; //获取子级id接口

    private Function<T,Object> treeRootId;//获取上级id接口

    private BiConsumer<T,List> treeSetList;//用于setList的接口

    /**
     *  传入根节点与非根节点,实现三个函数接口
     * @param rootList 根节点
     * @param bodyList  非根节点
     * @param treeId    函数->获取id
     * @param treeRootId    ->获取根id
     * @param treeSetList   ->保存集合方法
     */
    public TreeUtil(List<T> rootList, List<T> bodyList, Function treeId, Function treeRootId, BiConsumer treeSetList) {
        this.rootList = rootList;
        this.bodyList = bodyList;
        this.treeId = treeId;
        this.treeRootId = treeRootId;
        this.treeSetList = treeSetList;
    }

    /**
     *传入集合,实现三个函数接口
     * @param salesAreaTrees 集合
     * @param treeId     函数->获取id
     * @param treeRootId    ->获取根id
     * @param treeSetList   ->保存集合方法
     */
    public TreeUtil(List<T> salesAreaTrees, Function treeId, Function treeRootId, BiConsumer treeSetList) {
        this.treeId = treeId;
        this.treeRootId = treeRootId;
        this.treeSetList = treeSetList;
        //调用内部方法分离出根节点与非根节点
        this.getRootList(salesAreaTrees);
    }

    public List<T> getTree() {   //调用的方法入口
        if (bodyList != null && !bodyList.isEmpty()) {
            //声明一个map，用来过滤已操作过的数据
            Map<Object, Object> map = Maps.newHashMapWithExpectedSize(bodyList.size());
            rootList.forEach(beanTree -> getChild(beanTree, map));
            return rootList;
        }
        return rootList;
    }

    private void getChild(T t, Map<Object, Object> map) {
        List<T> childList = new ArrayList<>();
        bodyList.stream()
                .filter(c -> !map.containsKey(treeId.apply(c)))
                .filter(c -> Objects.equals(this.treeRootId.apply(c),this.treeId.apply(t)))
                .forEach(c -> {
                    map.put(this.treeId.apply(c), this.treeRootId.apply(c));
                    getChild(c, map);
                    childList.add(c);
                });
        this.treeSetList.accept(t, childList);
    }

    /**
     * 得到RootList和BodyList
     *
     * @param list
     */
    private void getRootList(List<T> list) {
        rootList = new ArrayList<>();
        bodyList = new ArrayList<>();
        List<Object> ids = list.stream()
                .parallel()
                .map(p -> this.treeId.apply(p))
                .collect(Collectors.toList());
        List<Object> pids = list.stream()
                .parallel()
                .map(p -> this.treeRootId.apply(p))
                .collect(Collectors.toList());

        //(求id和pid的交集->用于推导非根节点 )
        List<Object> notRootPids = ids.stream()
                .parallel()
                .filter(id -> pids.contains(id))
                .collect(Collectors.toList());


        //非根节点
        rootList=list.stream()
                .parallel()
                .filter(item -> !notRootPids.contains(this.treeRootId.apply(item)))
                .collect(Collectors.toList());
        //通过非根节点->根节点
        bodyList = list.stream()
                .parallel()
                .filter(item -> !rootList.contains(item))
                .collect(Collectors.toList());
    }
}

第一篇博客,记录一下
在这里插入图片描述