树结构展示

已于 2023-06-25 16:48:29 修改
阅读量298 收藏 1
点赞数 1
文章标签： java servlet 数据库
于 2023-06-25 15:23:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43447266/article/details/131377565
版权

树结构

树结构

方式一：一张表

一张表中含有id pid name 等字段

后台代码
    @RequestMapping("/showTree")
    public ABResponse showTree(){
        ABResponse groupGetAll = remoteService.group_getAll();
        List<RmGroup> getAllData = (List<RmGroup>) groupGetAll.getData();

        List<Menu>  menuList= new ArrayList<Menu>();

        for (int i = 0; i < getAllData.size(); i++) {
            Menu menu = new Menu();
            menu.setId(String.valueOf(getAllData.get(i).getId()));
            menu.setPid(String.valueOf(getAllData.get(i).getParentId()));
            menu.setText(getAllData.get(i).getName());
            menuList.add(menu);
        }
        /*让我们创建树*/
        MenuTree menuTree =new MenuTree(menuList);
        menuList=menuTree.builTree();

        String jsonOutput= JSON.toJSONString(menuList);
        System.out.println(jsonOutput);

        return ABResponse.buildSuccessData(jsonOutput);
    }
工具类

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

public class MenuTree {
    private List<Menu> menuList = new ArrayList<Menu>();
    public MenuTree(List<Menu> menuList) {
        this.menuList=menuList;
    }

    //建立树形结构
    public List<Menu> builTree(){
        List<Menu> treeMenus =new  ArrayList<Menu>();
        for(Menu menuNode : getRootNode()) {
            menuNode=buildChilTree(menuNode);
            treeMenus.add(menuNode);
        }
        return treeMenus;
    }

    //递归，建立子树形结构
    private Menu buildChilTree(Menu pNode){
        List<Menu> chilMenus =new  ArrayList<Menu>();
        for(Menu menuNode : menuList) {
            if(menuNode.getPid().equals(pNode.getId())) {
                chilMenus.add(buildChilTree(menuNode));
            }
        }
        pNode.setNodes(chilMenus);
        return pNode;
    }

    //获取根节点
    private List<Menu> getRootNode() {
        List<Menu> rootMenuLists =new  ArrayList<Menu>();
        for(Menu menuNode : menuList) {
            if(menuNode.getPid().equals("0")) {
                rootMenuLists.add(menuNode);
            }
        }
        return rootMenuLists;
    }
}
实体类
package com.abview.pojo;

import com.fasterxml.jackson.annotation.JsonProperty;

import java.util.List;

public class Menu {
    private String id;
    @JsonProperty(value = "pid")
    private String pid;
    private String text;
    private String url;
    private String yxbz;

    public Menu() {
    }

    @JsonProperty(value = "nodes")
    private List<Menu> nodes;

    public Menu(String id, String pid, String text, String url, String yxbz) {
        this.id = id;
        this.pid = pid;
        this.text = text;
        this.url = url;
        this.yxbz = yxbz;
    }
    /*省略get\set*/

    public String getId() {
        return id;
    }

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

    public String getPid() {
        return pid;
    }

    public void setPid(String pid) {
        this.pid = pid;
    }

    public List<Menu> getNodes() {
        return nodes;
    }

    public void setNodes(List<Menu> nodes) {
        this.nodes = nodes;
    }

    public String getText() {
        return text;
    }

    public void setText(String text) {
        this.text = text;
    }

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public String getYxbz() {
        return yxbz;
    }

    public void setYxbz(String yxbz) {
        this.yxbz = yxbz;
    }

}
前端代码使用treeview实现
<!DOCTYPE html>
<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title>移动到</title>
    <script type="text/javascript" src="../../../js/jquery/jquery-2.1.4/jquery.min.js"></script>
    <script src="../../../js/common/extends.js"></script>
    <script src="../../../js/common/Utils.js"></script>
    <script type="text/javascript" src="../../../js/jquery/jquery.form.js"></script>
    <link rel="stylesheet" type="text/css" href="../../../js/bootstrap/css/bootstrap.min.css"/>
    <script src="../../../js/bootstrap/js/bootstrap.min.js" type="text/javascript"></script>
    <script type="text/javascript" src="../../../js/bootstrap/js/bootbox.min.js"></script>
    <script type='text/javascript' src='../../../js/icheck-1.x/icheck.js'></script>
    <link rel="stylesheet" href="../../../js/icheck-1.x/skins/icheck.css" type="text/css"/>
    <script src="../../../js/bootstrap/js/bootstrapValidator.js" type="text/javascript"></script>
 //  下面是treeview
    <link href="../../../js/bootstrap-treeview/bootstrap-treeview.min.css" rel="stylesheet"/>
    <script src="../../../js/bootstrap-treeview/bootstrap-treeview.min.js" type="text/javascript"></script>


    <style>
        #tv {
            border: 1px solid #D6D6D6;
            display: none;
            width: 300px;
            height: 400px;
            overflow-x: hidden;
            overflow-y: auto;
        }
    </style>
    <script>
        MoveDevBackUtils = {
            submit: function () {
                //    获取设备id和分组id
                var pid = $("#pid").val();
                var deviceId = $("#deviceId").val();
                if (pid == null||pid === "") {
                    parent.parent.toastr["error"]("分组名称不存在");
                    return;
                }

                $.ajax({
                    url: '../../../ra/tree/moveDevice',
                    dataType: 'json',
                    data: {
                        pid: pid,
                        deviceId: deviceId
                    },
                    method: 'post',
                    success: function (data) {
                        parent.TopoListUtils.closeMoveDevice();
                        parent.TopoListUtils.refreshTopoList();
                        parent.parent.toastr["info"]("成功！");
                        parent.parent.parent.topoObject.flushMenu();
                    },
                    error: function () {
                        parent.parent.toastr["error"]("请重试！");
                    }
                })
            },

            getGroupId: function () {
                //    获取设备mac地址和分组id
                var pid = $("#pid").val();
                var mac = $("#deviceId").val();
                if (pid == null||pid === "") {
                    parent.parent.toastr["error"]("分组名称不存在");
                    return;
                }
                return pid;
            },




            init: function () {
                var iddata = $.UrlUtils.getParam("iddata");
                $("#deviceId").val(iddata);

                var nodeData = [];

                $.ajax({
                    url: '../../../ra/tree/showTree',
                    type: 'post',
                    dataType: 'json',
                    async: false,
                    success: function (data) {
                        nodeData = data.data;
                    }
                })

                $('#tv').treeview({
                    data: nodeData,                        // 节点数据
                    levels: 1,                             // 节点层级数
                    color: "#000",                         // 每一级通用的 节点字体颜色
                    backColor: "#fff",                     // 每一级通用的 节点字背景色
                    onhoverColor: "skyblue",               // 选中浮动颜色
                    showBorder: false,                     // 不显示边框
                    showTags: true,                        // 是否在每个节点的右侧显示标签。 其值必须在每个节点的数据结构中提供
                    highlightSelected: true,               // 是否突出显示选定的节点
                    selectedColor: "#fff",                 // 设置选定节点的前景色
                    selectedBackColor: "skyblue",          // 设置选定节点的背景色
                    onNodeSelected: function (event, data) {
                        $('#region').val(data.text);
                        $('#pid').val(data.id);
                        $('#tv').hide();
                    }
                })

                $('#region').click(function () {
                    $('#tv').show();
                })


            }
        }
    </script>
</head>

<body>
<div class="container">
    <div class="row-fluid">
        <div class="row">
            <div class="col-md-offset-4 col-md-3">
                <form id="moveGroupForm">
                    <div class="form-group">
                        <input id="pid" value="" hidden>
                        <input id="deviceId" value="" hidden>
                        <label for="region">分组名称</label>
                        <input id="region" class="form-control" value="Root" type="text" placeholder="请选择分组"
                               style="width:200px;" name="groupName"/>
                        <div id="tv"></div>
                    </div>

<!--                    <div class="form-group" style="margin-bottom: 10px ">-->
<!--                        <input class="btn btn-primary" value="确认" onclick="MoveDevUtils.submit()"/>-->
<!--                    </div>-->
                </form>
            </div>
        </div>
    </div>
</div>

<script>

    $(function () {
        MoveDevBackUtils.init();
    });

</script>

</body>
</html>

模拟数据进行展示

进行数据模拟展示

package com.example.demo2;

import com.alibaba.fastjson.JSON;
import com.example.demo.entry.Menu;
import com.example.demo.utils.MenuTreeData;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;
//  classes = DemoApplicationTests.class 独立运行避免出错
@SpringBootTest(classes = DemoApplicationTests.class)
class DemoApplicationTests {
//   这个速度快
    @Test
    void contextLoads() {
        //模拟从数据库查询出来
        List<Menu> menus = Arrays.asList(
                new Menu(1,"商品管理",0),
                new Menu(2,"会员管理",0),
                new Menu(3,"系统管理",0),
                new Menu(4,"系统工具",0),
                new Menu(5,"用户管理",3),
                new Menu(6,"角色管理",3),
                new Menu(7,"菜单栏管理",3),
                new Menu(8,"日志管理",4),
                new Menu(9,"商品列表",1),
                new Menu(10,"订单列表",1),
                new Menu(11,"会员等级",2),
                new Menu(12,"品牌列表",1)
        );

        //获取父节点
        List<Menu> collect = menus.stream().filter(m -> m.getParentId() == 0).map(
                (m) -> {
                    m.setChildList(getChildrens(m, menus));
                    return m;
                }
        ).collect(Collectors.toList());
        System.out.println("-------转json输出结果-------");
        System.out.println(JSON.toJSON(collect));
    }

    /**
     * 递归查询子节点
     * @param root  根节点
     * @param all   所有节点
     * @return 根节点信息
     */
    private List<Menu> getChildrens(Menu root, List<Menu> all) {
        List<Menu> children = all.stream().filter(m -> {
            return Objects.equals(m.getParentId(), root.getId());
        }).map(
                (m) -> {
                    m.setChildList(getChildrens(m, all));
                    return m;
                }
        ).collect(Collectors.toList());
        return children;
    }


    @Test
    void contextLoads2() {
        //模拟从数据库查询出来
        List<Menu> menus = Arrays.asList(
                new Menu(1,"商品管理",0),
                new Menu(2,"会员管理",0),
                new Menu(3,"系统管理",0),
                new Menu(4,"系统工具",0),
                new Menu(5,"用户管理",3),
                new Menu(6,"角色管理",3),
                new Menu(7,"菜单栏管理",3),
                new Menu(8,"日志管理",4),
                new Menu(9,"商品列表",1),
                new Menu(10,"订单列表",1),
                new Menu(11,"会员等级",2),
                new Menu(12,"品牌列表",1)
        );
        List<Menu> list = buildDeptTreeByStream(menus);
        System.out.println(list);
        System.out.println(JSON.toJSON(list));
    }
    public static List<Menu> buildDeptTreeByStream(List<Menu> trees){
        //获取parentId = 0的根节点
        List<Menu> list = trees.stream().filter(item -> item.getParentId() == 0L).collect(Collectors.toList());
        //根据parentId进行分组
        Map<Integer, List<Menu>> map = trees.stream().collect(Collectors.groupingBy(Menu::getParentId));
        recursionFnTree(list, map);
        return list;
    }

    /**
     * 递归遍历节点
     * @param list
     * @param map
     */
    public static void recursionFnTree(List<Menu> list, Map<Integer, List<Menu>> map){
        for (Menu treeSelect : list) {
            List<Menu> childList = map.get(treeSelect.getId());
            treeSelect.setChildList(childList);
            if (null != childList && 0 < childList.size()){
                recursionFnTree(childList,map);
            }
        }
    }

    @Test
    void contextLoads3() {
        //模拟从数据库查询出来
        List<Menu> menus = Arrays.asList(
                new Menu(1,"商品管理",0),
                new Menu(2,"会员管理",0),
                new Menu(3,"系统管理",0),
                new Menu(4,"系统工具",0),
                new Menu(5,"用户管理",3),
                new Menu(6,"角色管理",3),
                new Menu(7,"菜单栏管理",3),
                new Menu(8,"日志管理",4),
                new Menu(9,"商品列表",1),
                new Menu(10,"订单列表",1),
                new Menu(11,"会员等级",2),
                new Menu(12,"品牌列表",1)
        );
        List<Menu> list = MenuTreeData.buildDeptTree(menus);
        System.out.println(list);
        System.out.println(JSON.toJSON(list));
    }


}
contextLoads3 里调用的方法
package com.example.demo.utils;

import com.example.demo.entry.Menu;

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

public class MenuTreeData {

    /**
     * 构建前端所需要树结构
     *
     * @param trees 列表
     * @return 树结构列表
     */
    public static List<Menu> buildDeptTree(List<Menu> trees) {
        List<Menu> returnList = new ArrayList<Menu>();
        List<Long> tempList = new ArrayList<Long>();
        for (Menu dept : trees) {
            tempList.add(Long.valueOf(dept.getId()));
        }
        for (Iterator<Menu> iterator = trees.iterator(); iterator.hasNext(); ) {
            Menu treeSelect = (Menu) iterator.next();
            // 如果是顶级节点, 遍历该父节点的所有子节点
            if (!tempList.contains(treeSelect.getParentId())) {
                recursionFn(trees, treeSelect);
                returnList.add(treeSelect);
            }
        }
        if (returnList.isEmpty()) {
            returnList = trees;
        }
        return returnList;
    }

    /**
     * 递归列表
     */
    private static void recursionFn(List<Menu> list, Menu t) {
        // 得到子节点列表
        List<Menu> childList = getChildList(list, t);
        t.setChildList(childList);
        for (Menu tChild : childList) {
            if (hasChild(list, tChild)) {
                recursionFn(list, tChild);
            }
        }
    }

    /**
     * 得到子节点列表
     */
    private static List<Menu> getChildList(List<Menu> list, Menu t) {
        List<Menu> tlist = new ArrayList<Menu>();
        for (Menu n : list) {
            if (n.getParentId() != null && n.getParentId() == t.getId()) {
                tlist.add(n);
            }
        }
        return tlist;
    }

    /**
     * 判断是否有子节点
     */
    private static boolean hasChild(List<Menu> list, Menu t) {
        return getChildList(list, t).size() > 0;
    }
}
实体类
package com.example.demo.entry;

import lombok.Builder;
import lombok.Data;

import java.util.List;

/**
 * 树结构：Menu
 */
@Data
@Builder
public class Menu {
    /**
     * id
     */
    public Integer id;
    /**
     * 名称
     */
    public String name;
    /**
     * 父id ，根节点为0
     */
    public Integer parentId;
    /**
     * 子节点信息
     */
    public List<Menu> childList;

    public Integer getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public Integer getParentId() {
        return parentId;
    }

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

    public List<Menu> getChildList() {
        return childList;
    }

    public void setChildList(List<Menu> childList) {
        this.childList = childList;
    }

    public Menu(Integer id, String name, Integer parentId) {
        this.id = id;
        this.name = name;
        this.parentId = parentId;
    }

    public Menu(Integer id, String name, Integer parentId, List<Menu> childList) {
        this.id = id;
        this.name = name;
        this.parentId = parentId;
        this.childList = childList;
    }

}
显示数据结果
[Menu(id=1, name=商品管理, parentId=0, childList=[Menu(id=9, name=商品列表, parentId=1, childList=[]), Menu(id=10, name=订单列表, parentId=1, childList=[]), Menu(id=12, name=品牌列表, parentId=1, childList=[])]), Menu(id=2, name=会员管理, parentId=0, childList=[Menu(id=11, name=会员等级, parentId=2, childList=[])]), Menu(id=3, name=系统管理, parentId=0, childList=[Menu(id=5, name=用户管理, parentId=3, childList=[]), Menu(id=6, name=角色管理, parentId=3, childList=[]), Menu(id=7, name=菜单栏管理, parentId=3, childList=[])]), Menu(id=4, name=系统工具, parentId=0, childList=[Menu(id=8, name=日志管理, parentId=4, childList=[])]), Menu(id=5, name=用户管理, parentId=3, childList=[]), Menu(id=6, name=角色管理, parentId=3, childList=[]), Menu(id=7, name=菜单栏管理, parentId=3, childList=[]), Menu(id=8, name=日志管理, parentId=4, childList=[]), Menu(id=9, name=商品列表, parentId=1, childList=[]), Menu(id=10, name=订单列表, parentId=1, childList=[]), Menu(id=11, name=会员等级, parentId=2, childList=[]), Menu(id=12, name=品牌列表, parentId=1, childList=[])]
[{"name":"商品管理","childList":[{"name":"商品列表","childList":[],"id":9,"parentId":1},{"name":"订单列表","childList":[],"id":10,"parentId":1},{"name":"品牌列表","childList":[],"id":12,"parentId":1}],"id":1,"parentId":0},{"name":"会员管理","childList":[{"name":"会员等级","childList":[],"id":11,"parentId":2}],"id":2,"parentId":0},{"name":"系统管理","childList":[{"name":"用户管理","childList":[],"id":5,"parentId":3},{"name":"角色管理","childList":[],"id":6,"parentId":3},{"name":"菜单栏管理","childList":[],"id":7,"parentId":3}],"id":3,"parentId":0},{"name":"系统工具","childList":[{"name":"日志管理","childList":[],"id":8,"parentId":4}],"id":4,"parentId":0},{"name":"用户管理","childList":[],"id":5,"parentId":3},{"name":"角色管理","childList":[],"id":6,"parentId":3},{"name":"菜单栏管理","childList":[],"id":7,"parentId":3},{"name":"日志管理","childList":[],"id":8,"parentId":4},{"name":"商品列表","childList":[],"id":9,"parentId":1},{"name":"订单列表","childList":[],"id":10,"parentId":1},{"name":"会员等级","childList":[],"id":11,"parentId":2},{"name":"品牌列表","childList":[],"id":12,"parentId":1}]

方式二 ：两张表

两张表，例如:group表1中包含id pid name等字段 ；device表2中包含id groupId(表1的主键id字段) name 等其他字段

后台代码
public String device_getListAll2() {

        Map<String, List<TreeData>> rtnMap = new HashMap<String, List<TreeData>>();
        List<RmDevice> allDevList = deviceDao.getAll();
        String groupId = "";
        for (RmDevice dev : allDevList) {
            TreeData map = new TreeData();
            map.setId(dev.getId());
            map.setGroupId(dev.getGroupId());
            map.setIp(utils.ip.toFrontEnd(dev.getIp()));
            map.setMac(utils.mac.toFrontEnd(dev.getMac()));
            map.setName(dev.getName());
            map.setModel(dev.getModel());
            map.setSoftwareVersion(dev.getSoftwareVersion());
            map.setSystemVersion(dev.getSystemVersion());
            map.setIconCls("icon-driver");
            if (dev.getGroupId() == 0) {
                groupId = "1";
                map.setParentId(1);
            } else {
                groupId = String.valueOf(dev.getGroupId());
                map.setParentId(dev.getGroupId());
            }
            map.setMark(dev.getId() + "_" + 1);
            map.setType("1");

            if (rtnMap.containsKey(groupId)) {
                List<TreeData> tempList = rtnMap.get(groupId);
                tempList.add(map);
            } else {
                List<TreeData> tempList = new ArrayList<TreeData>();
                tempList.add(map);
                rtnMap.put(groupId, tempList);
            }
        }

        //分组
        List<RmGroup> allGroupList = groupDao.getAll();
        List<TreeData> returnList = getGroupChild(allGroupList, 0, rtnMap);

        return JSON.toJSONString(returnList);
    }

 private List<TreeData> getGroupChild(List<RmGroup> list, int root, Map<String, List<TreeData>> rtnMap) {
        List<TreeData> treeList = new ArrayList<TreeData>();
        for (RmGroup grp : list) {
            TreeData tree = new TreeData();
            tree.setId(grp.getId());
            tree.setName(grp.getName());
            tree.setParentId(grp.getParentId());
            tree.setIconCls("icon-function");
            int parentId = grp.getParentId();
            int treeId = grp.getId();
            if (root == parentId) {
                List<TreeData> lists = getGroupChild(list, treeId, rtnMap);

                if (rtnMap.get(String.valueOf(grp.getId())) != null) {
                    lists.addAll(rtnMap.get(String.valueOf(grp.getId())));
                }
                tree.setChildren(lists);
                treeList.add(tree);
            }
        }
        return treeList;
    }
实体类


public class TreeData{


	private static final long serialVersionUID = 1L;

	private int id;
	private String name;
	private int groupId;
	private String ip;
	private String mac;
	private String model;
	private String softwareVersion;
	private String systemVersion;
	private int parentId;
	private List<TreeData> children;
	private String mark;
	private String type;

	private String iconCls;

	public String getIconCls() {
		return iconCls;
	}

	public void setIconCls(String iconCls) {
		this.iconCls = iconCls;
	}

	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getGroupId() {
		return groupId;
	}
	public void setGroupId(int groupId) {
		this.groupId = groupId;
	}
	public String getIp() {
		return ip;
	}
	public void setIp(String ip) {
		this.ip = ip;
	}
	public String getMac() {
		return mac;
	}
	public void setMac(String mac) {
		this.mac = mac;
	}
	public String getSoftwareVersion() {
		return softwareVersion;
	}
	public void setSoftwareVersion(String softwareVersion) {
		this.softwareVersion = softwareVersion;
	}
	public String getSystemVersion() {
		return systemVersion;
	}
	public void setSystemVersion(String systemVersion) {
		this.systemVersion = systemVersion;
	}
	public int getParentId() {
		return parentId;
	}
	public void setParentId(int parentId) {
		this.parentId = parentId;
	}
	public List<TreeData> getChildren() {
		return children;
	}
	public void setChildren(List<TreeData> children) {
		this.children = children;
	}
	public String getMark() {
		return mark;
	}
	public void setMark(String mark) {
		this.mark = mark;
	}
	public String getType() {
		return type;
	}
	public void setType(String type) {
		this.type = type;
	}

	public String getModel() {
		return model;
	}

	public void setModel(String model) {
		this.model = model;
	}

	public TreeData() {
	}

	public TreeData(int id, String name, int groupId, String ip, String mac, String model, String softwareVersion, String systemVersion, int parentId, List<TreeData> children, String mark, String type) {
		this.id = id;
		this.name = name;
		this.groupId = groupId;
		this.ip = ip;
		this.mac = mac;
		this.model = model;
		this.softwareVersion = softwareVersion;
		this.systemVersion = systemVersion;
		this.parentId = parentId;
		this.children = children;
		this.mark = mark;
		this.type = type;
	}
}
前端代码

可以使用esayui里面的treegrid表格样式，也可以用其他的。比如layui

刘昕hrf
关注
linux树目录展示,Linux下使用tree命令以树形结构显示文件夹目录结构
weixin_42443533的博客
04-28 2734
tree命令功能说明：以树状图列出目录的内容。如：tree 以树状图显示所有文件tree -L N 以树状图显示所有文件，子文件夹显示到第 N 层Ubuntu安装tree命令sudo apt-get install tree查看关于tree命令的帮助信息linuxidc@linuxidc:~$ tree --helpusage: tree [-acdfghilnpqrstuvxACDFJQNSUX...
前端页面实现树形结构
热门推荐
qq_38729043的博客
12-05 2万+
树形结构
vue项目+el-tree，树结构展示，非常完整的代码，包含调接口拿真实数据渲染
花椒和蕊的博客
04-16 6137
温故而知新，最近项目中频繁使用树形结构展示效果，因为不熟悉，备受折磨。 代码贴出来，再复习一次。 代码太长了，想看分析的可以搜我下一篇文章，下一篇会详细的写如何在项目中使用 效果：左侧是树，右侧是表格。点击任何一行都会展示对应的表格 **完整代码如下：**模板区 <el-card > <div style="display: flex; justify-content: start"> <div class="leftBox">
微信小程序实现文件目录树结构展示
weixin_43272072的博客
07-01 6080
微信小程序文件夹目录结构显示 最近做微信小程序，碰到列表展示客户信息。含有二级目录，想做成资源管理器那种加减号显示文件目录。找了好久小程序官方文档，没有找到百度也没有，只能自己琢磨了，还好做出来了。多了不说，直接上代码和需求。 后台接口返回数据格式：{ "data": [ { "id": 2, "sets_name": "分组1", "file_path": null, "create_time...
ElementUI Tree 树形结构展示
小猫爪子
10-20 3939
后台传过来已经封装好的树形数据
python 学习之：通过树结构展示文件夹/目录
qq_42902997的博客
12-14 1117
【代码】python 学习之：通过树结构展示文件夹/目录。
java 以树形结构展示文件夹内容
abments的博客
06-28 1339
java 以树形结构展示文件夹内容
django树形结构展示
Colinspace
04-22 3010
1、使用Django自带的标签 unordered_list 1.1、定义模型 class Department(models.Model): name = models.CharField(max_length=64, unique=True, verbose_name="部门名称") # db_constraint 控制是否在数据库中为此外键创建约束，默认为True。在数据库中创建外键约束是数据库规范中明令禁止的行为 # 但是不影响Django的关联查询 parent = models.Fore
redis存储树结构数据
thanksm1的博客
10-03 1万+
本文主要讲解两方面内容：1.redis如何存储树结构数据。2.java操作redis时选取哪种序列化器。 redis如何存储树结构数据 先抛出结论，树结构数据在redis中的存储顺序如下： ...
导出和区域树结构展示.zip
01-07
"导出和区域树结构展示.zip"文件很可能包含了关于如何创建、编辑以及导出思维导图，特别是强调区域树结构的详细步骤。这个压缩包可能包含了一个演示文稿或教程，指导用户如何利用特定软件或工具来构建这样的结构。 ...
Python 文件处理 18_递归算法原理_目录树结构展示.mp4
02-09
Python 文件处理 18_递归算法原理_目录树结构展示.mp4
android树形菜单，树形结构，多级展示
07-24
树形菜单，用来展示有层次结构的数据，像文件管理器，一个文件夹下面有很多文件，文件夹，可能文件夹下面还有文件还有文件夹。我们需要展示这些结构，但是安卓并没有提供一个比较方便的控件来展示,所以就需要我们...
基于Layui的表格树形结构展示组件设计源码
05-27
本设计源码提供了一个基于Layui的表格树形结构展示组件，包含53个文件，其中包括24个js脚本文件，5个css样式文件，4个md文档，4个json数据文件，3个gif图片文件，2个png图片文件，2个php源文件，2个html页面文件，...
wpf datagrid实现树结构.rar
11-01
本项目“wpf datagrid实现树结构”就是针对这种需求的一个实例，它展示了如何在WPF的DataGrid中实现树状的数据展示。 首先，我们来理解一下核心概念。WPF的DataGrid控件默认并不支持树形结构，但可以通过自定义模板...
HashMap为什么线程不安全？
rnnf_yyds的博客
11-03 719
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
spring循环依赖解决方式
qq_36400213的博客
11-04 870
字段注入和setter注入则提供了更多的灵活性，但需要更谨慎地管理对象的状态。方法注入和注解注入则适用于特定的场景。在Spring框架中，依赖注入（Dependency Injection，DI）是一种实现控制反转（Inversion of Control，IoC）的机制，用于将对象的依赖关系自动注入到对象中。这种方式不如构造器注入严格，但比字段注入更灵活，因为它可以在不创建新实例的情况下改变对象的依赖。这种方式是推荐的，因为它可以保证对象在创建时就处于完全初始化的状态，并且可以使得bean不可变。
【Java知识】Java基础-对象排序的实现
最新发布
wendao76的专栏
11-04 331
方法，并且需要提供一个比较器（Comparator）来定义对象的排序逻辑。这些示例展示了如何在Java中对对象进行排序，无论是使用列表还是数组，都可以灵活地使用比较器来定义排序规则。在Java中，对象的排序通常涉及到使用。
信息学科平台系统开发：基于Spring Boot的最佳实践
2401_85761762的博客
11-02 1044
在整个系统测试中，根据需求文档和设计文档，逐一对功能进行检测并写好测试用例，有效避免残片缺陷，因为产品出现缺陷不仅影响功能，而且可以导致数据的不准确，导致产品质量的降低，经过测试，才能使得产品的稳定性和成熟度得到极大的提升，产品质量也才有保证。本系统具有易操作、易管理、交互性好的特点，在操作上是非常简单的，因此在操作上具有很高的可行性。（2）该完整内容全面，管理方便可以及时的全面的处理各种错误，异常，这样避免了很多因用户的马虎操作而出现的失误，其操作方便，用户界面友好，能够上网的人都可以很好的进行操作。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值