根据数据中父节点id遍历出树状结构

业务中有需求,每个分类都有上一级id(父节点id),根据这个id,组装成树状结构

下面People是我的实体类,Model是树状结构的类

转成json用到了fastjson,主要是可以去json格式转换器那里看具体的结构

		<dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.41</version>
        </dependency>
        <!-- 实体类中我用的lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

lombok需要下载lombok插件

这个是People实体类,需要组建成树状结构的类

import lombok.Data;
@Data
public class People {
    private String id;
    private String name;
    private String pid;
}

Model树状结构的类

import lombok.Data;
import lombok.Getter;
import lombok.Setter;
import java.util.List;
@Data
@Getter
@Setter
public class Model {
    private String value;
    private String label;
    private List<Model> children;
}

实际的操作的类

package com.example.demo.gong.tree;
import com.alibaba.fastjson.JSONObject;
import org.apache.commons.lang3.StringUtils;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class TreeUtil {
    public static void main(String[] args) {
        List<People> peopleList = getList();
        Model parentModel = new Model();
        parentModel.setLabel("开始节点");
        parentModel.setValue("");
        parentModel.setChildren(new ArrayList<>());

        Map<String, People> map = new HashMap<>();

        Map<String, List<Model>> modelMap = new HashMap<>();
        modelMap.put("", new ArrayList<>());

        for (People people : peopleList) {
            map.put(people.getId(), people);
        }
        for (People people : peopleList) {
            Model model = new Model();
            if (map.get(people.getId()) != null) {
                model.setValue(people.getId());
                model.setLabel(people.getName());
                model.setChildren(new ArrayList<>());
            } else {
                model.setValue("");
                model.setLabel("");
                model.setChildren(new ArrayList<>());
            }
            if (StringUtils.isEmpty(people.getPid()) || map.get(people.getPid()) == null) {
                parentModel.getChildren().add(model);
                modelMap.get("").add(model);
                continue;
            }
            if (modelMap.get(people.getPid()) == null) {
                List<Model> list = new ArrayList();
                list.add(model);
                if (!StringUtils.isEmpty(people.getPid())) {
                    modelMap.put(people.getPid(), list);
                }
            } else {
                modelMap.get(people.getPid()).add(model);
            }
        }
        recursion(parentModel,modelMap);
        //测试
        String s = JSONObject.toJSONString(parentModel);
        System.out.println(s);
    }
    //递归,将数据转换成树状
    private static void recursion(Model model, Map<String, List<Model>> selectVoMap) {
        if (model.getChildren() == null || model.getChildren().size() == 0) {

        } else {
            for (Model selectVoFor : model.getChildren()) {
                model.setChildren(selectVoMap.get(model.getValue()));
                selectVoFor.setChildren(selectVoMap.get(selectVoFor.getValue()));
                recursion(selectVoFor, selectVoMap);
            }
        }
    }



    //造假数据,比较懒,所以直接用的数字代替
    public static List<People> getList() {
        List<People> list = new ArrayList();
        People people1 = getPeople("1", "11", null);
        People people2 = getPeople("2", "22", "1");
        People people3 = getPeople("3", "33", "1");
        People people4 = getPeople("4", "44", "2");
        People people5 = getPeople("5", "55", "4");
        People people6 = getPeople("6", "66", "3");
        People people7 = getPeople("7", "77", "6");
        list.add(people1);
        list.add(people2);
        list.add(people3);
        list.add(people4);
        list.add(people5);
        list.add(people6);
        list.add(people7);
        return list;
    }
    public static People getPeople(String id, String name, String pid) {
        People people = new People();
        people.setId(id);
        people.setName(name);
        people.setPid(pid);
        return people;
    }
}

新写了一套树结构方案

实体类

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.List;

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class Node {
    private String id;
    private String templateId;
    private String nodeName;
    private Integer nodeLevel;
    private String parentId;
    private Integer isMust;
    private List<Node> nodeList;
}

测试代码

import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.json.JSONUtil;
import org.springframework.util.CollectionUtils;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;

public class Test {
    public static void main(String[] args) {
        List<Node> nodeList = nodeList();
        // 获取到根节点
        List<Node> nodeParentList = nodeList.stream().filter(node -> node.getNodeLevel().equals(1)).collect(Collectors.toList());
        Map<String, List<Node>> parentMap = nodeList.stream().collect(Collectors.groupingBy(Node::getParentId));
        for (Node parentNode : nodeParentList) {
            recursion(parentNode, parentMap);
        }
        System.out.println(JSONUtil.toJsonStr(nodeParentList));
    }

    public static void recursion(Node parentNode, Map<String, List<Node>> parentMap) {
        List<Node> nodeList = parentMap.get(parentNode.getId());
        if (CollectionUtil.isNotEmpty(nodeList)) {
            parentNode.setNodeList(nodeList);
            for (Node node : nodeList) {
                recursion(node, parentMap);
            }
        } else {
            parentNode.setNodeList(Collections.EMPTY_LIST);
        }
    }


    public static List<Node> nodeList() {
        List<Node> nodeList = new ArrayList<>();
        Node n1 = Node.builder().id("1").nodeLevel(1).nodeName("a").parentId("0").build();
        Node n2 = Node.builder().id("2").nodeLevel(1).nodeName("b").parentId("0").build();

        Node n3 = Node.builder().id("3").nodeLevel(2).nodeName("a1").parentId("1").build();
        Node n4 = Node.builder().id("4").nodeLevel(2).nodeName("a2").parentId("1").build();
        Node n5 = Node.builder().id("5").nodeLevel(2).nodeName("b1").parentId("2").build();
        Node n6 = Node.builder().id("6").nodeLevel(2).nodeName("b2").parentId("2").build();

        Node n7 = Node.builder().id("7").nodeLevel(3).nodeName("a11").parentId("3").build();
        Node n8 = Node.builder().id("8").nodeLevel(3).nodeName("a12").parentId("3").build();
        Node n9 = Node.builder().id("9").nodeLevel(3).nodeName("a21").parentId("4").build();
        Node n10 = Node.builder().id("10").nodeLevel(3).nodeName("a22").parentId("4").build();
        Node n11 = Node.builder().id("11").nodeLevel(3).nodeName("b11").parentId("5").build();
        Node n12 = Node.builder().id("12").nodeLevel(3).nodeName("b12").parentId("5").build();
        Node n13 = Node.builder().id("13").nodeLevel(3).nodeName("b21").parentId("6").build();
        Node n14 = Node.builder().id("14").nodeLevel(3).nodeName("b22").parentId("6").build();

        Node n15 = Node.builder().id("15").nodeLevel(4).nodeName("a111").parentId("7").build();
        Node n16 = Node.builder().id("16").nodeLevel(4).nodeName("a112").parentId("7").build();
        Node n17 = Node.builder().id("17").nodeLevel(4).nodeName("a121").parentId("8").build();
        Node n18 = Node.builder().id("18").nodeLevel(4).nodeName("a122").parentId("8").build();
        nodeList.add(n1);
        nodeList.add(n2);
        nodeList.add(n3);
        nodeList.add(n4);
        nodeList.add(n5);
        nodeList.add(n6);
        nodeList.add(n7);
        nodeList.add(n8);
        nodeList.add(n9);
        nodeList.add(n10);
        nodeList.add(n11);
        nodeList.add(n12);
        nodeList.add(n13);
        nodeList.add(n14);
        nodeList.add(n15);
        nodeList.add(n16);
        nodeList.add(n17);
        nodeList.add(n18);
        return nodeList;
    }
}
  • 2
    点赞
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值