多级菜单 树结构 排序 前端 后端 java

这篇具有很好参考价值的文章主要介绍了多级菜单 树结构 排序 前端 后端 java。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

目录

省流:

正文: 

v1.0版 

前端传的值:

后端代码:

v2.0版

v3.0版


省流:

前端提交过来整个树即可。 

给整个树进行sort。代码如下:

    public static void sort(List<Node> tree){
        int i = 0;
        for (Node o : tree) {
            o.setSort(i++);
            if(o.getChild()!=null){
                sort(o.getChild());
            }
        }
    }

这个只是单纯排序,没有替换parentId。升级版本见正文。

排序完以后,结果如下:

一级节点的sort:1,2,3,4...

二级节点的sort:每个一级节点下的二级节点,都会从1开始排序:1,2,3,4...

|-- 一级节点1
    |--二级节点1
    |--二级节点2
    |--二级节点3
|-- 一级节点2
    |--二级节点1
    |--二级节点2
    |--二级节点3
|-- 一级节点3
    |--二级节点1
    |--二级节点2
    |--二级节点3

 

正文: 

 

v1.0版 

前端传的值:

{
    "id": "雪花id",
    "parentId": "雪花id",
	"name":"书籍",
	"sort":"1",
    "children": [
        {
            "id": "雪花id",
            "parentId": "雪花id",
            "name": "数学",
            "sort": 1,
            "children": [
                {
                    "children": [],
                    "id": "雪花id",
                    "parentId": "雪花id",
                    "name": "几何学",
                    "sort": 1,

                },
                {
                    "children": [],
                    "id": "雪花id",
                    "parentId": "雪花id",
                    "name": "代数学",
                    "sort": 2,
                },
                {
                    "children": [],
                    "id": "雪花id",
                    "parentId": "雪花id",
                    "name": "概率学",
                    "sort": 3,
                }
            ]

        },
        {
            "id": "雪花id",
            "parentId": "雪花id",
            "name": "物理",
            "sort": 2,
            "children": [
                {
                    "children": [],
                    "id": "雪花id",
                    "parentId": "雪花id",
                    "name": "光学",
                    "sort": 1,

                },
                {
                    "children": [],
                    "id": "雪花id",
                    "parentId": "雪花id",
                    "name": "力学",
                    "sort": 2,
                },
                {
                    "children": [],
                    "id": "雪花id",
                    "parentId": "雪花id",
                    "name": "量子学",
                    "sort": 3,
                }
            ]
        },
        {
            "id": "雪花id",
            "parentId": "雪花id",
            "name": "化学",
            "sort": 3,
            "children": [
                {
                    "children": [],
                    "id": "雪花id",
                    "parentId": "雪花id",
                    "name": "有机学",
                    "sort": 1,

                },
                {
                    "children": [],
                    "id": "雪花id",
                    "parentId": "雪花id",
                    "name": "无机学",
                    "sort": 2,
                },
                {
                    "children": [],
                    "id": "雪花id",
                    "parentId": "雪花id",
                    "name": "应用化学",
                    "sort": 3,
                }
            ]
        }
    ]
}

后端代码:

后端模拟前端传值单元测试: 

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

public class SortT1 {
    public static void main(String[] args) {
        //一级节点
        Node firstNode1 = new Node();
        Node firstNode2 = new Node();
        Node firstNode3 = new Node();
        List<Node> first = new ArrayList<>(Arrays.asList(firstNode1,firstNode2,firstNode3));

        //二级节点
        Node sec1First1 = new Node();
        Node sec2First1 = new Node();
        Node sec3First1 = new Node();
        List<Node> second1 = new ArrayList<>(Arrays.asList(sec1First1,sec2First1,sec3First1));
        firstNode1.setChild(second1);

        Node sec1First2 = new Node();
        Node sec2First2 = new Node();
        Node sec3First2 = new Node();
        List<Node> second2 = new ArrayList<>(Arrays.asList(sec1First2,sec2First2,sec3First2));
        firstNode2.setChild(second2);

        Node sec1First3 = new Node();
        Node sec2First3 = new Node();
        Node sec3First3 = new Node();
        List<Node> second3 = new ArrayList<>(Arrays.asList(sec1First3,sec2First3,sec3First3));
        firstNode3.setChild(second3);

        sort(first);

        System.out.println(first);
    }

    public static void sort(List<Node> tree){
        int i = 0;
        for (Node o : tree) {
            o.setSort(i++);
            if(o.getChild()!=null){
                sort(o.getChild());
            }
        }
    }
}

 

import java.util.List;

public class Node {
    private Integer sort;
    private List<Node> child;

    public Integer getSort() {
        return sort;
    }

    public void setSort(Integer sort) {
        this.sort = sort;
    }

    public List<Node> getChild() {
        return child;
    }

    public void setChild(List<Node> child) {
        this.child = child;
    }
}

v2.0版

增加parentId

    public static void main(String[] args) {
        //一级节点
        Node firstNode1 = new Node("0001");
        Node firstNode2 = new Node("0002");
        Node firstNode3 = new Node("0003");
        List<Node> first = new ArrayList<>(Arrays.asList(firstNode1,firstNode2,firstNode3));

        //二级节点
        Node sec1First1 = new Node("00010001");
        Node sec2First1 = new Node("00010002");
        Node sec3First1 = new Node("00010003");
        List<Node> second1 = new ArrayList<>(Arrays.asList(sec1First1,sec2First1,sec3First1));
        firstNode1.setChild(second1);

        Node sec1First2 = new Node("00020001");
        Node sec2First2 = new Node("00020002");
        Node sec3First2 = new Node("00020003");
        List<Node> second2 = new ArrayList<>(Arrays.asList(sec1First2,sec2First2,sec3First2));
        firstNode2.setChild(second2);

        Node sec1First3 = new Node("00030001");
        Node sec2First3 = new Node("00030002");
        Node sec3First3 = new Node("00030003");
        List<Node> second3 = new ArrayList<>(Arrays.asList(sec1First3,sec2First3,sec3First3));
        firstNode3.setChild(second3);

        sort(first, "0");

        System.out.println(first);
    }
    public static void sort(List<Node> tree,String parentId){
        int i = 0;
        for (Node o : tree) {
            o.setSort(i++);
            o.setParentId(parentId);
            if(o.getChild()!=null){
                sort(o.getChild(),o.getId());
            }
        }
    }
public class Node {
    public Node(String id){
        this.id = id;
    }
    private Integer sort;
    private List<Node> child;
    private String id;
    private String parentId;
//省略了get set方法没写,自己测的时候记得加上
}

v3.0版

 保存到数据库:将所有节点都放到一个list里。

    public static void main(String[] args) {
        //省略前面的代码
        //...
        List<Node> result = new ArrayList<>();
        sort(first, "0", result);
        //将结果集保存到数据库
        xxxMapper.saveOrUpdate(result);
    }

    public static void sort(List<Node> tree,String parentId,List<Node> result){
        int i = 0;
        for (Node o : tree) {
            o.setSort(i++);
            o.setParentId(parentId);
            if(o.getChild()!=null){
                sort(o.getChild(),o.getId(),result);
            }
            o.setChild(null);//递归走出来后就不需要child了
            result.add(o);//将当前节点存到结果集里
        }
    }

注意:为了避免意外发生,生产上记得加上深度,以防万一出现死循环导致栈溢出stackoverflow。

 

===================分割线===================

文章到此已经结束,以下是紫薯布丁

|-- 一级节点1
    |--二级节点1
    |--二级节点2
    |--二级节点3
|-- 一级节点2
    |--二级节点1
    |--二级节点2
    |--二级节点3
|-- 一级节点3
    |--二级节点1
    |--二级节点2
    |--二级节点3

{
    "id": "雪花id",
    "parentId": "雪花id",
    "name":"书籍",
    "sort":"1",
    "children": [
        {
            "id": "雪花id",
            "parentId": "雪花id",
            "name": "数学",
            "sort": 1,
            "children": [
                {
                    "children": [],
                    "id": "雪花id",
                    "parentId": "雪花id",
                    "name": "几何学",
                    "sort": 1,

                },
                {
                    "children": [],
                    "id": "雪花id",
                    "parentId": "雪花id",
                    "name": "代数学",
                    "sort": 2,
                },
                {
                    "children": [],
                    "id": "雪花id",
                    "parentId": "雪花id",
                    "name": "概率学",
                    "sort": 3,
                }
            ]

        },
        {
            "id": "雪花id",
            "parentId": "雪花id",
            "name": "物理",
            "sort": 2,
            "children": [
                {
                    "children": [],
                    "id": "雪花id",
                    "parentId": "雪花id",
                    "name": "光学",
                    "sort": 1,

                },
                {
                    "children": [],
                    "id": "雪花id",
                    "parentId": "雪花id",
                    "name": "力学",
                    "sort": 2,
                },
                {
                    "children": [],
                    "id": "雪花id",
                    "parentId": "雪花id",
                    "name": "量子学",
                    "sort": 3,
                }
            ]
        },
        {
            "id": "雪花id",
            "parentId": "雪花id",
            "name": "化学",
            "sort": 3,
            "children": [
                {
                    "children": [],
                    "id": "雪花id",
                    "parentId": "雪花id",
                    "name": "有机学",
                    "sort": 1,

                },
                {
                    "children": [],
                    "id": "雪花id",
                    "parentId": "雪花id",
                    "name": "无机学",
                    "sort": 2,
                },
                {
                    "children": [],
                    "id": "雪花id",
                    "parentId": "雪花id",
                    "name": "应用化学",
                    "sort": 3,
                }
            ]
        }
    ]
}

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

public class SortT1 {
    public static void main(String[] args) {
        //一级节点
        Node firstNode1 = new Node();
        Node firstNode2 = new Node();
        Node firstNode3 = new Node();
        List<Node> first = new ArrayList<>(Arrays.asList(firstNode1,firstNode2,firstNode3));

        //二级节点
        Node sec1First1 = new Node();
        Node sec2First1 = new Node();
        Node sec3First1 = new Node();
        List<Node> second1 = new ArrayList<>(Arrays.asList(sec1First1,sec2First1,sec3First1));
        firstNode1.setChild(second1);

        Node sec1First2 = new Node();
        Node sec2First2 = new Node();
        Node sec3First2 = new Node();
        List<Node> second2 = new ArrayList<>(Arrays.asList(sec1First2,sec2First2,sec3First2));
        firstNode2.setChild(second2);

        Node sec1First3 = new Node();
        Node sec2First3 = new Node();
        Node sec3First3 = new Node();
        List<Node> second3 = new ArrayList<>(Arrays.asList(sec1First3,sec2First3,sec3First3));
        firstNode3.setChild(second3);

        sort(first);

        System.out.println(first);
    }

    public static void sort(List<Node> tree){
        int i = 0;
        for (Node o : tree) {
            o.setSort(i++);
            if(o.getChild()!=null){
                sort(o.getChild());
            }
        }
    }
}
 

    public static void main(String[] args) {
        List<Node> result = new ArrayList<>();
        sort(first, "0", result);
        //将结果集保存到数据库
        xxxMapper.saveOrUpdate(result);
    }

    public static void sort(List<Node> tree,String parentId,List<Node> result){
        int i = 0;
        for (Node o : tree) {
            o.setSort(i++);
            o.setParentId(parentId);
            if(o.getChild()!=null){
                sort(o.getChild(),o.getId(),result);
            }
            o.setChild(null);//递归走出来后就不需要child了
            result.add(o);//将当前节点存到结果集里
        }
    }
 

public class Node {
    public Node(String id){
        this.id = id;
    }
    private Integer sort;
    private List<Node> child;
    private String id;
    private String parentId;
//省略了get set方法没写,自己测的时候记得加上
}文章来源地址https://www.toymoban.com/news/detail-741224.html

到了这里,关于多级菜单 树结构 排序 前端 后端 java的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 简易oled多级菜单实现

      最近在学习如何实现oled多级菜单时,查看了大多数博主发的文章,大概似懂的文章内容可让我好一阵思考,于是我觉得应该有一篇更加简单易懂的文章能轻易上手;我们实现项目时一定先要准备以下知识点:1. 结构体 2.结构体数组 3.函数指针 (如果还有没有这方面的C语言

    2024年02月05日
    浏览(65)
  • 基于gin关于多级菜单的处理

    多级菜单是很多业务场景需要的。下面是一种处理方式 下面是model

    2024年02月12日
    浏览(32)
  • 如何查询多级菜单(采用递归的方法)

    应用场景 1.京东 京东的页面就是这么显示的在家用电器下面有电视.空调.洗衣机然后再电视下面又有全面屏电视.教育电视等等 2.我们的后端管理系统 我们后端在页面上显示的很多也是通过层级目录的显示出来。 如何实现 我们这里parent_id为0的为我们的一级菜单 注意我们需要

    2024年02月14日
    浏览(46)
  • STM32_OLED多级菜单

    程序实现 多级菜单显示实则是多个界面的跳转,这个版本更加适合初学者。我使用了两个按键,一个用来选择下一项,另一个用来确定选项。所以我们暂时叫他next键和enter键。先定义一个结构体,结构体里面有四个变量,分别代表当前索引号,next键,enter键和当前执行函数。

    2024年02月11日
    浏览(46)
  • 【Python】Selenium多级悬浮菜单定位方法分享

    举例图: 以下菜单选择需逐级鼠标悬浮显示才可选择 注明: 示例代码: 本文均为本人编写,本文如有侵权请告知删除。

    2024年02月12日
    浏览(36)
  • QT使用QTreeWidget控件制作多级折叠菜单

    记录项目中实际用到的多级折叠菜单实现方式:项目代码简化版( 亲测可用 ) 开发环境:VS2015+QT5.9.1 多级菜单(左右共两个图标,中间为文字,左图标为固定静态图标,右图标为折叠/展开动态图标),格式如下: 图片 菜单标题      图片            系统配置       

    2024年02月09日
    浏览(40)
  • STM32+OLED屏多级菜单显示(三)

            前面两章实现了OLED屏幕显示的基本功能,这一章就做一个多级菜单显示功能         单片机选择STM32F103C8T6最小系统板,OLED屏选择0.96寸OLED显示器,除了单片机和OLED屏之外,还需要三个按键(下一位键、确认键和返回键),当然一个按键也可以(单击、双击和长击

    2024年02月03日
    浏览(37)
  • STM32简易多级菜单(数组查表法)

    单片机开发中,有时会用到屏幕来显示内容,当需要逐级显示内容时,就需要使用多级菜单的形式了。 多级菜单的实现,大体分为两种设计思路: 通过双向链表实现 通过数组查表实现 总体思路都是把菜单的各个界面联系起来,可以从上级菜单跳到下级菜单,也可从下级菜单

    2024年02月02日
    浏览(62)
  • 【Android】【BUG】BRVAH3.x实现多级菜单中子菜单无法点击的问题

    使用BRVAH进行多级菜单效果实现时,子菜单的点击事件怎么也不行,根本无法获取点击事件。 子项的xml布局 修改为 这就解决了,这谁顶得住啊…

    2024年02月13日
    浏览(38)
  • QT实现多级下拉列表导航菜单,可折叠(QTreewidget实现)

    目录 创建多级列表 在ui中拖入一个QTreewidget控件。 双击该控件,打开编辑树窗口部件。​编辑​编辑 进行列表控件设置: 在项目前添加图标: 效果: QT实现多级下拉列表,可折叠 做项目的时候需要实现一个可折叠的多级下拉列表,用QTreewidget就可以实现,而且直接在ui文件

    2024年02月16日
    浏览(52)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包