# TreeHelper

**Repository Path**: ludi_git/tree-helper

## Basic Information

- **Project Name**: TreeHelper
- **Description**: 使用JAVA进行树状数据格式转换
1、获取指定指定树状结构列表的节点数据
2、平铺数据建立成树(将仅有节点和父节点的对象列表转换为含有children的树状结构)
3、将树状结构转换为平铺数据结构(将含有children的树状结构转换为仅有节点和父节点的对象列表)
- **Primary Language**: Java
- **License**: MulanPSL-2.0
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 3
- **Forks**: 1
- **Created**: 2021-01-29
- **Last Updated**: 2022-08-11

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# TreeHelper

#### 介绍

JAVA

1、获取指定指定树状结构列表的节点数据

2、平铺数据建立成树(将仅有节点和父节点的对象列表转换为含有children的树状结构)

3、将树状结构转换为平铺数据结构(将含有children的树状结构转换为仅有节点和父节点的对象列表)

```java
package utile;

import entity.TreeStructure;
import entity.TreeSourceNode;

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

/**
 * @Description: 树状结构工具类
 * @Author: ld
 * @Date: 2021-01-28 17:55
 */
public class TreeHelper {

    private TreeHelper(){

    }
        /**
         * 获取指定树状结构中的某节点的详细数据
         * @param treeStructureList 指定树状结构列表数据
         * @param nodeId  指定节点id
         * @param <T> 任意参数
         * @return 指定id的详细数据
         */
        public static <T extends TreeSourceNode> TreeStructure<T> getNode(List<TreeStructure<T>> treeStructureList, String nodeId) {
            //1、树状结构数据平铺
            List<TreeStructure<T>> objList =  new ArrayList<TreeStructure<T>>();
            //2、获取指定节点数据
            for (TreeStructure<T> obj:convertToObjList(treeStructureList)) {
                if(nodeId.equals(obj.getId())){
                    return obj;
                }
            }
            return null;
        }

    /**
     * 将树状结构转换为平铺数据结构(将含有children的树状结构转换为仅有节点和父节点的对象列表)
     * @param source 树状结构数据列表
     * @param <T> 任意类型参数
     * @return 平铺数据结构列表
     */
    public static <T extends TreeSourceNode> List<TreeStructure<T>> convertToObjList(List<TreeStructure<T>> source){
        List<TreeStructure<T>> outList = new ArrayList<>();
        for (TreeStructure<T> tTreeStructure : source) {
            if (tTreeStructure.getChildren() != null) {
                outList.add(tTreeStructure);
                convertToObjList(tTreeStructure.getChildren(), outList);
            } else {
                outList.add(tTreeStructure);
            }
        }
        return outList;
    }


        /**
         * 将树状结构转换为平铺数据结构(将含有children的树状结构转换为仅有节点和父节点的对象列表)
         * @param source 树状结构数据列表
         * @param outList 平铺数据结构列表
         * @param <T> 任意类型参数
         */
        public static <T extends TreeSourceNode> void convertToObjList(List<TreeStructure<T>> source , List<TreeStructure<T>> outList){
            if(outList==null){
                outList = new ArrayList<>();
            }
            for (TreeStructure<T> tTreeStructure : source) {
                if (tTreeStructure.getChildren() != null) {
                    outList.add(tTreeStructure);
                    convertToObjList(tTreeStructure.getChildren(), outList);
                } else {
                    outList.add(tTreeStructure);
                }
            }
        }

        /**
         * 平铺数据建立成树(将仅有节点和父节点的对象列表转换为含有children的树状结构)
         * @param sourceNodeList 平铺数据列表
         * @param <T> 任意
         * @return 树状结构数据
         */
        public static <T extends TreeSourceNode> List<TreeStructure<T>> convertToTreeList(List<T> sourceNodeList) {
            List<TreeStructure<T>> destNodeList = new ArrayList<TreeStructure<T>>();
            //第一步，找出第一级的节点
            //1.1 统计所有节点的id
            List<String> allIds = new ArrayList<String>();
            for (T sourceNode : sourceNodeList) {
                allIds.add(sourceNode.getId());
            }
            //所有父节点找不到对应的都是一级id
            for (T sourceNode : sourceNodeList) {
                if (!allIds.contains(sourceNode.getParentId())) {
                    //从每个一级节点，递归查找children
                    TreeStructure<T> destNode = new TreeStructure<T>();
                    destNode.setId(sourceNode.getId());
                    destNode.setName(sourceNode.getName());
                    destNode.setLevel(1);
                    destNode.setParentId(sourceNode.getParentId());
                    List<TreeStructure<T>> myChildes = getChildren(sourceNodeList, destNode);
                    destNode.setChildren(myChildes.isEmpty() ? null : myChildes);
                    destNodeList.add(destNode);
                }
            }
            return destNodeList;
        }

        //    递归获取子节点
        private static <T extends TreeSourceNode> List<TreeStructure<T>> getChildren(List<T> sourceNodeList, TreeStructure<T> parentNode) {
            List<TreeStructure<T>> childrenList = new ArrayList<TreeStructure<T>>();
            for (T sourceNode : sourceNodeList) {
                if (parentNode.getId().equals(sourceNode.getParentId())) {
                    TreeStructure<T> children = new TreeStructure<T>();
                    children.setId(sourceNode.getId());
                    children.setName(sourceNode.getName());
                    children.setLevel(parentNode.getLevel() + 1);
                    children.setParentId(sourceNode.getParentId());
                    List<TreeStructure<T>> myChilds = getChildren(sourceNodeList, children);
                    children.setChildren(myChilds.isEmpty() ? null : myChilds);
                    childrenList.add(children);
                }
            }
            return childrenList;
        }
    }




```