构建树 Tree

最新推荐文章于 2024-04-29 15:44:22 发布
最新推荐文章于 2024-04-29 15:44:22 发布
阅读量286 收藏
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Dyson_HQ/article/details/111940404
版权 
   @Override
    public Tree treeWithSpaceCameraAndCollect(Long buildingId) {
        // 查出所有设备，构造树
        List<EquipmentCollect> equipmentCollects = this.baseMapper.selectCollectByBuildingId(buildingId);
        Tree linkSectorParentTree;
        if (equipmentCollects.size() == 0) {
            Tree<Object> emptyTree = new Tree<>();
            linkSectorParentTree = emptyTree;
        } else {
            // 关联了楼层的设备
            List<EquipmentCollect> linkedSector = equipmentCollects.stream()
                    .filter(e -> !ObjectUtils.isEmpty(e.getFloorId()))
                    .collect(Collectors.toList());
            // 防区ID分组的设备
            Map<Long, List<EquipmentCollect>> floorCollect = linkedSector.stream()
                    .collect(Collectors.groupingBy(EquipmentCollect::getFloorId));
            linkSectorParentTree = buildSpaceTree(floorCollect);
        }
        // 查出所有摄像头，构造树
        List<EquipmentCamera> equipmentCameras = this.baseMapper.selectCameraByBuildingId(buildingId);
        Tree linkSectorCameraParentTree;
        if (equipmentCameras.size() == 0) {
            Tree<Object> emptyTree = new Tree<>();
            linkSectorCameraParentTree = emptyTree;
        } else {
            // 关联了防区的摄像头
            List<EquipmentCamera> linkedSectorCamera = equipmentCameras.stream()
                    .filter(e -> !ObjectUtils.isEmpty(e.getFloorId()))
                    .collect(Collectors.toList());
            // 防区ID分组的摄像头
            Map<Long, List<EquipmentCamera>> floorCamers = linkedSectorCamera.stream()
                    .collect(Collectors.groupingBy(EquipmentCamera::getFloorId));

            linkSectorCameraParentTree = buildCameraSpaceTree(floorCamers);
        }
        List<Tree> parent = Arrays.asList(linkSectorParentTree, linkSectorCameraParentTree);
        Tree root = new Tree<>();
        root.setChildren(parent);
        root.setId("0");
        root.setKey("0");
        return root;
    }

在这里插入代码片


 private Tree buildSpaceTree(Map<Long, List<EquipmentCollect>> floorCollect) {
        List<Long> floorIds = new ArrayList<>(floorCollect.keySet());
        String ids = StringUtils.join(floorIds, ",");
        // 只显示关联楼层的摄像头树节点
        Collection<BuildingFloor> buidingFloor = spaceService.getFloorByIds(ids);

        Map<Long, Map<Long, Map<Long, List<BuildingFloor>>>> treeGroup = buidingFloor.stream()
                .collect(Collectors.groupingBy(BuildingFloor::getParkId,
                        Collectors.groupingBy(BuildingFloor::getBuildingId,
                                Collectors.groupingBy(BuildingFloor::getId))));

        Tree linkSectorParentTree = new Tree();
        List<Tree<Park>> linkSectorChildren = new ArrayList<>();
        linkSectorParentTree.setId("linkSectorParentTree");
        linkSectorParentTree.setKey("linkSectorParentTree");
        linkSectorParentTree.setParentId("0");
        linkSectorParentTree.setLabel("采集设备");
        linkSectorParentTree.setChildren(linkSectorChildren);
        treeGroup.forEach((parkId, parks) -> {
            Tree parkTree = new Tree();
            List<Tree<ParkBuilding>> parkChildren = new ArrayList<>();
            Park parkById = spaceService.getParkById(parkId);
            parkTree.setLabel(parkById.getParkName());
            parkTree.setId("parkId-" + parkId);
            parkTree.setKey("parkId-" + parkId);
            parkTree.setParentId("linkSectorParentTree");
            parkTree.setChildren(parkChildren);
            linkSectorChildren.add(parkTree);
            parks.forEach((buildingId, builds) -> {
                Tree buildTree = new Tree();
                List<Tree<BuildingFloor>> buildChildren = new ArrayList<>();
                ParkBuilding parkBuildingById = spaceService.getParkBuildingById(buildingId);
                buildTree.setLabel(parkBuildingById.getBuildingName());
                buildTree.setId("buildingId-" + buildingId);
                buildTree.setKey("buildingId-" + buildingId);
                buildTree.setParentId("parkId-" + parkId);
                buildTree.setChildren(buildChildren);
                parkChildren.add(buildTree);
                builds.forEach((floorId, floors) -> {
                    Tree floorTree = new Tree();
                    List<Tree<BuildingSector>> floorChildren = new ArrayList<>();
                    BuildingFloor buildingFloorById = spaceService.getBuildingFloorById(floorId);
                    floorTree.setLabel(buildingFloorById.getFloorName());
                    floorTree.setId("floorId-" + floorId);
                    floorTree.setKey("floorId-" + floorId);
                    floorTree.setParentId("buildingId-" + buildingId);
                    floorTree.setChildren(floorChildren);
                    buildChildren.add(floorTree);

                    // 循环该楼层下的设备
                    List<EquipmentCollect> collects = floorCollect.get(floorId);
                    collects.forEach(c -> {
                        Tree lastNode = new Tree<>();
                        lastNode.setId("collectId-" + c.getId());
                        lastNode.setKey("collectId-" + c.getId());
                        lastNode.setValue(c.getCollectName());
                        lastNode.setParentId("floorId-" + floorId);
                        BuildingFloor floor = spaceService.getBuildingFloorById(floorId);
                        c.setFloorCode(floor.getFloorCode());
                        lastNode.setProp(c);
                        lastNode.setLabel(c.getCollectName());
                        floorChildren.add(lastNode);
                    });
                });
            });
        });
        return linkSectorParentTree;
    }
在这里插入代码片


    private Tree buildCameraSpaceTree(Map<Long, List<EquipmentCamera>> floorCameras) {
        List<Long> sectorIds = new ArrayList<>(floorCameras.keySet());
        String ids = StringUtils.join(sectorIds, ",");
        // 只显示关联防区的摄像头树节点
        Collection<BuildingFloor> buildingFloors = spaceService.getFloorByIds(ids);

        Map<Long, Map<Long, Map<Long, List<BuildingFloor>>>> treeGroup = buildingFloors.stream()
                .collect(Collectors.groupingBy(BuildingFloor::getParkId,
                        Collectors.groupingBy(BuildingFloor::getBuildingId,
                                Collectors.groupingBy(BuildingFloor::getId))));

        Tree linkSectorCameraParentTree = new Tree();
        List<Tree<Park>> linkSectorChildren = new ArrayList<>();
        linkSectorCameraParentTree.setId("linkSectorCameraParentTree");
        linkSectorCameraParentTree.setKey("linkSectorCameraParentTree");
        linkSectorCameraParentTree.setParentId("0");
        linkSectorCameraParentTree.setLabel("监控设备");
        linkSectorCameraParentTree.setChildren(linkSectorChildren);
        treeGroup.forEach((parkId, parks) -> {
            Tree parkTree = new Tree();
            List<Tree<ParkBuilding>> parkChildren = new ArrayList<>();
            Park parkById = spaceService.getParkById(parkId);
            parkTree.setLabel(parkById.getParkName());
            parkTree.setId("parkId-" + parkId);
            parkTree.setKey("parkId-" + parkId);
            parkTree.setParentId("linkSectorCameraParentTree");
            parkTree.setChildren(parkChildren);
            linkSectorChildren.add(parkTree);
            parks.forEach((buildingId, builds) -> {
                Tree buildTree = new Tree();
                List<Tree<BuildingFloor>> buildChildren = new ArrayList<>();
                ParkBuilding parkBuildingById = spaceService.getParkBuildingById(buildingId);
                buildTree.setLabel(parkBuildingById.getBuildingName());
                buildTree.setId("buildingId-" + buildingId);
                buildTree.setKey("buildingId-" + buildingId);
                buildTree.setParentId("parkId-" + parkId);
                buildTree.setChildren(buildChildren);
                parkChildren.add(buildTree);
                builds.forEach((floorId, floors) -> {
                    Tree floorTree = new Tree();
                    List<Tree<BuildingSector>> floorChildren = new ArrayList<>();
                    BuildingFloor buildingFloorById = spaceService.getBuildingFloorById(floorId);
                    floorTree.setLabel(buildingFloorById.getFloorName());
                    floorTree.setId("floorId-" + floorId);
                    floorTree.setKey("floorId-" + floorId);
                    floorTree.setParentId("buildingId-" + buildingId);
                    floorTree.setChildren(floorChildren);
                    buildChildren.add(floorTree);

                    // 循环该楼层下的监控摄像头
                    List<EquipmentCamera> cameras = floorCameras.get(floorId);
                    cameras.forEach(c -> {
                        Tree cameraTree = new Tree<>();
                        cameraTree.setId("cameraId-" + c.getId());
                        cameraTree.setKey("cameraId-" + c.getId());
                        cameraTree.setValue(c.getStreamUrl());
                        cameraTree.setParentId("floorId-" + floorId);
                        BuildingFloor floor = spaceService.getBuildingFloorById(floorId);
                        c.setFloorCode(floor.getFloorCode());
                        cameraTree.setProp(c);
                        cameraTree.setLabel(c.getCameraName());
                        floorChildren.add(cameraTree);
                    });
                });
            });
        });
        return linkSectorCameraParentTree;
    }
在这里插入代码片

import com.fasterxml.jackson.annotation.JsonInclude;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
@Data
@JsonInclude(JsonInclude.Include.NON_NULL)
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class Tree<T> {

    public static final String[] pathList = new String[]{"A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N"};

    private String id;

    private String parentId;

    private String label;

    private String key;

    private String icon;

    private Map slots;

    private String title;

    private String value;

    private String text;

    private String permission;

    private String description;

    private String deptName;

    private Long deptId;

    private String userTotal;

    private String userLoginTotal;

    private String loginRate;

    private String type;

    private boolean disabled;  //是否可以选择

    private String linkType;

    private T prop;

    private Integer order;

    private String path;

    private String component;

    private List<Tree<T>> children;

    private boolean hasParent = false;

    private boolean hasChildren = false;

    private Date createTime;

    private Date modifyTime;

    public void initChildren() {
        this.children = new ArrayList<>();
    }
在这里插入代码片

在这里插入图片描述

Dyson_Huang
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
TreeView构建树工具
08-15
TreeView控件用来显示信息的分级视图，如同Windows里的资源管理器的目录。TreeView控件中的各项信息都有一个与之相关的Node对象。TreeView显示Node对象的分层目录结构，每个Node对象均由一个Label对象和其相关的位图组成。在建立TreeView控件后，我们可以展开和折叠、显示或隐藏其中的节点。TreeView控件一般用来显示文件和目录结构、文档中的类层次、索引中的层次和其他具有分层目录结构的信息。
Tree构建
weixin_30872499的博客
04-13 74
后端构建一颗树，返回前端，如下所示。 [ { "Guid": "0ada72a1-0c29-4a49-80f2-adeeae4409bd", "id": 1, "text": "苏泊尔", "children": [ { "Guid": "27be15...
【Threejs】获取相交网格相交线
最新发布
qq_61834461的博客
04-29 276
【代码】【Threejs】获取相交网格相交线。
tree 树状构建
weixin_30871293的博客
03-07 106
/*package ch.util; import com.trm.model.func.FunctionTree; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Set; public class FunctionUtil ...
构建tree
qq_37588808的博客
08-29 125
集合构建tree
树的构建
weixin_39940241的博客
04-16 928
二叉树的构建(前中、前后、中后) 关联LeetCode105,106,889 LeetCode 105根据一棵树的前序遍历与中序遍历构造二叉树 LeetCode 106根据一棵树的中序遍历与后序遍历构造二叉树 LeetCode 889根据前序和后序遍历构造二叉树 这三题建议一起做,可以很好地熟悉递归以及二叉树 所需要的基础知识(熟悉的可以跳过): 树的三种遍历 前序遍历(先访问根结点,再访问左子树,最后访问右子树,简称根左右) 中序遍历(左根右) 后序遍历(左右根) 下面给出对应的java代码 前
基于jstree使用AJAX请求获取数据形成树
10-19
总的来说，这个示例展示了如何使用jstree与AJAX结合，动态地从服务器获取数据并构建树结构。开发者可以根据自己的需求调整AJAX请求的URL、数据处理逻辑以及jstree的配置，以适应不同的应用场景。记得将`url`替换为你...
java简单开发部门树（Tree）
09-27
- TreeNode类：定义一个TreeNode类，包含部门ID、名称、父节点ID等属性，以及添加子节点的方法，方便构建树形结构。 4. **数据查询优化**： - 预加载策略：为了避免频繁的数据库查询，可以采用预加载策略，一次性...
使用jsTree实现js树形结构
06-07
**jsTree：构建前端树形结构的利器** jsTree 是一个强大的 JavaScript 库，专用于在 Web 页面上创建交互式的树形结构。它基于纯 JavaScript 编写，无需依赖其他库，因此对于初学者和有经验的开发者来说，都是一个...
构建sp-tree
09-24
**构建SP-Tree** SP-Tree（Space Partition Tree），即空间分割树，是一种高效的数据索引结构，尤其适用于多维空间中的数据管理。在数据库、地理信息系统、图像处理等领域，SP-Tree被广泛用于加速查询、删除和查找...
Decision Tree_decisiontree_决策树_
10-01
决策树（Decision Tree）是一种广泛应用于数据挖掘与机器学习领域的算法模型，它的主要任务是根据输入数据中的特征来做出一系列的决策，最终形成一个类似树状结构的模型。这种模型直观易懂，易于解释，因此在分类和...
递归构建一整棵树
07-24
通过递归方法构建树形结构数据，比如无限层级菜单，可供新手学习递归算法
在Java中构建树型菜单
12-02
javascript树型菜单(Dtree和Xtree) dtree构建动态树型菜单
three-mesh-bvh:BVH实现可加快针对Three.js网格的光线投射
05-02
三目BVH 一个BVH实现，可以加快光线投射的速度，并启用three.js网格的相交测试。 以60帧/秒的速度向80,000个多边形模型投射500条光线！ 用 使用预制函数 // Import via ES6 modules import * as THREE from 'three' ; import { computeBoundsTree , disposeBoundsTree , acceleratedRaycast } from 'three-mesh-bvh' ; // Or UMD const { computeBoundsTree , disposeBoundsTree , acceleratedRaycast } = window . MeshBVHLib ; // Add the extension functions THREE . BufferGeometry .
树的建立
weixin_30302609的博客
04-26 593
1代码 ··· BTree CreateBTree(string str,int i){ int len; BTree bt; bt=new TNode; len=str.size(); if(i>len-1 || i<=0) return NULL; if(str[i] == '#') return NULL; bt->data = str[i]; bt->lchild ...
java构建树
苏杭
04-13 205
public class KthNode { public static class TreeNode{ int val=0; TreeNode left=null; TreeNode right=null; //构造函数 public TreeNode(int val){ this.val=val; } } public static void constrc.
重新构建树
Summit的专栏
10-26 421
重新构建树题目： 输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。思路： 首先要知道树的前序、中序和后序遍历，前中后都是对于根结点来说的。前序遍历：先访问根结点，再访问左子树，最后访问右子树中序遍历：先访问左子
构建树（孩子兄弟表示法）
caomm1982的专栏
05-17 3627
构建树（孩子兄弟表示法）
后缀树详解：构建与应用
"后缀树是一种高效的数据结构，主要用于处理字符串相关的问题，如字符串搜索、模式匹配、重复子串查找等。它通过压缩 Trie 的方式，存储字符串的所有后缀，从而实现快速查询和分析。本文将介绍后缀树的构造方法、...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值