java使用泛型实现树形

java使用泛型实现树形

本文大纲
一、树形的基本配置
二、树形构造
三、树形实体类
四、测试

一、树形的基本配置

package com.tree;

import java.util.List;

/**
 * 树形结构的基本配置
 *
 * @param <T> 列表
 */
public class TreeBase<T> {
    private Number id;

    private Number parentId;

    private List<T> children;


    public Number getId() {
        return id;
    }

    public void setId(Number id) {
        this.id = id;
    }

    public Number getParentId() {
        return parentId;
    }

    public void setParentId(Number parentId) {
        this.parentId = parentId;
    }

    public List<T> getChildren() {
        return children;
    }

    public void setChildren(List<T> children) {
        this.children = children;
    }
}

二、树形构造

package com.tree;

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

/**
 * 构造树形结构
 *
 * @param <T> 树形基本配置
 * @param <U> 树形根节点值
 */
public class TreeBulider<T extends TreeBase<T>, U> {
    // 列表
    private final List<T> list;
    // 根节点值
    private final U root;

    public TreeBulider(List<T> list, U root) {
        this.list = list;
        this.root = root;
    }

    /**
     * 建立树形结构
     *
     * @return
     */
    public List<T> buildTree() {
        if (root == null) {
            throw new RuntimeException("根值不能为空");
        }
        if (list == null || list.isEmpty()) {
            return new ArrayList<>();
        }
        List<T> tree = new ArrayList<>();
        List<T> rootNode = this.getRootNode();
        for (T operateNode : rootNode) {
            buildChildTree(operateNode);
            tree.add(operateNode);
        }
        return tree;
    }

    /**
     * 递归，建立子树形结构
     *
     * @param parentNode 父节点
     * @return
     */
    private T buildChildTree(T parentNode) {
        List<T> childMenus = new ArrayList<>();
        for (T menuNode : list) {
            if (menuNode.getParentId().equals(parentNode.getId())) {
                childMenus.add(buildChildTree(menuNode));
            }
        }
        parentNode.setChildren(childMenus);
        return parentNode;
    }

    /**
     * 获取根节点
     *
     * @return
     */
    private List<T> getRootNode() {
        List<T> rootMenuLists = new ArrayList<>();
        for (T menuNode : list) {
            // 找出根节点
            if (menuNode.getParentId().equals(root)) {
                rootMenuLists.add(menuNode);
            }
        }
        return rootMenuLists;
    }

}

三、树形实体类

继承TreeBase

package com.tree;

/**
 * 树形实体类
 */
public class Operate extends TreeBase {

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

四、测试

package com.tree;

import com.alibaba.fastjson.JSON;

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

public class TreeTest {

    public static void main(String[] args) {
        // 获取数据源
        List<Operate> list = list();

        List<Operate> operateTree1 = new TreeBulider<>(list,0L).buildTree();
        System.out.println(JSON.toJSONString(operateTree1));

        List<Operate> operateTree2 = new TreeBulider<>(list,0).buildTree();
        System.out.println(JSON.toJSONString(operateTree2));
    }


    // 模拟数据
    public static List<Operate> list() {
        List<Operate> operateList = new ArrayList<>();

        Operate operate10 = new Operate();
        operate10.setId(1L);
        operate10.setParentId(0L);
        operate10.setName("根目录1");

        operateList.add(operate10);

        Operate operate11 = new Operate();
        operate11.setId(11L);
        operate11.setParentId(1L);
        operate11.setName("子目录11");

        Operate operate12 = new Operate();
        operate12.setId(12L);
        operate12.setParentId(1L);
        operate12.setName("子目录12");

        operateList.add(operate11);
        operateList.add(operate12);


        Operate operate20 = new Operate();
        operate20.setId(2L);
        operate20.setParentId(0L);
        operate20.setName("根目录2");

        operateList.add(operate20);

        Operate operate21 = new Operate();
        operate21.setId(21L);
        operate21.setParentId(2L);
        operate21.setName("子目录21");

        Operate operate22 = new Operate();
        operate22.setId(22L);
        operate22.setParentId(2L);
        operate22.setName("子目录22");

        operateList.add(operate21);
        operateList.add(operate22);

        return operateList;
    }

}

运行结果（JSON格式化后，树形）：

[
    {
        "children": [
            {
                "children": [],
                "id": 11,
                "name": "子目录11",
                "parentId": 1
            },
            {
                "children": [],
                "id": 12,
                "name": "子目录12",
                "parentId": 1
            }
        ],
        "id": 1,
        "name": "根目录1",
        "parentId": 0
    },
    {
        "children": [
            {
                "children": [],
                "id": 21,
                "name": "子目录21",
                "parentId": 2
            },
            {
                "children": [],
                "id": 22,
                "name": "子目录22",
                "parentId": 2
            }
        ],
        "id": 2,
        "name": "根目录2",
        "parentId": 0
    }
]