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

    目录

    省流：

    正文： 

    v1.0版 

    前端传的值：

    后端代码：

    v2.0版

    v3.0版

    省流：

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

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

    1.     public static void sort(List tree){
    2.         int i = 0;
    3.         for (Node o : tree) {
    4.             o.setSort(i++);
    5.             if(o.getChild()!=null){
    6.                 sort(o.getChild());
    7.             }
    8.         }
    9.     }

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

    排序完以后，结果如下：

    一级节点的sort：1，2，3，4...

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

    1. |-- 一级节点1
    2.     |--二级节点1
    3.     |--二级节点2
    4.     |--二级节点3
    5. |-- 一级节点2
    6.     |--二级节点1
    7.     |--二级节点2
    8.     |--二级节点3
    9. |-- 一级节点3
    10.     |--二级节点1
    11.     |--二级节点2
    12.     |--二级节点3

     

    正文： 

     

    v1.0版 

    前端传的值：

    1. {
    2.     "id": "雪花id",
    3.     "parentId": "雪花id",
    4. 	"name":"书籍",
    5. 	"sort":"1",
    6.     "children": [
    7.         {
    8.             "id": "雪花id",
    9.             "parentId": "雪花id",
    10.             "name": "数学",
    11.             "sort": 1,
    12.             "children": [
    13.                 {
    14.                     "children": [],
    15.                     "id": "雪花id",
    16.                     "parentId": "雪花id",
    17.                     "name": "几何学",
    18.                     "sort": 1,
    19.  
    20.                 },
    21.                 {
    22.                     "children": [],
    23.                     "id": "雪花id",
    24.                     "parentId": "雪花id",
    25.                     "name": "代数学",
    26.                     "sort": 2,
    27.                 },
    28.                 {
    29.                     "children": [],
    30.                     "id": "雪花id",
    31.                     "parentId": "雪花id",
    32.                     "name": "概率学",
    33.                     "sort": 3,
    34.                 }
    35.             ]
    36.  
    37.         },
    38.         {
    39.             "id": "雪花id",
    40.             "parentId": "雪花id",
    41.             "name": "物理",
    42.             "sort": 2,
    43.             "children": [
    44.                 {
    45.                     "children": [],
    46.                     "id": "雪花id",
    47.                     "parentId": "雪花id",
    48.                     "name": "光学",
    49.                     "sort": 1,
    50.  
    51.                 },
    52.                 {
    53.                     "children": [],
    54.                     "id": "雪花id",
    55.                     "parentId": "雪花id",
    56.                     "name": "力学",
    57.                     "sort": 2,
    58.                 },
    59.                 {
    60.                     "children": [],
    61.                     "id": "雪花id",
    62.                     "parentId": "雪花id",
    63.                     "name": "量子学",
    64.                     "sort": 3,
    65.                 }
    66.             ]
    67.         },
    68.         {
    69.             "id": "雪花id",
    70.             "parentId": "雪花id",
    71.             "name": "化学",
    72.             "sort": 3,
    73.             "children": [
    74.                 {
    75.                     "children": [],
    76.                     "id": "雪花id",
    77.                     "parentId": "雪花id",
    78.                     "name": "有机学",
    79.                     "sort": 1,
    80.  
    81.                 },
    82.                 {
    83.                     "children": [],
    84.                     "id": "雪花id",
    85.                     "parentId": "雪花id",
    86.                     "name": "无机学",
    87.                     "sort": 2,
    88.                 },
    89.                 {
    90.                     "children": [],
    91.                     "id": "雪花id",
    92.                     "parentId": "雪花id",
    93.                     "name": "应用化学",
    94.                     "sort": 3,
    95.                 }
    96.             ]
    97.         }
    98.     ]
    99. }

    后端代码：

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

    1. import java.util.ArrayList;
    2. import java.util.Arrays;
    3. import java.util.List;
    4.  
    5. public class SortT1 {
    6.     public static void main(String[] args) {
    7.         //一级节点
    8.         Node firstNode1 = new Node();
    9.         Node firstNode2 = new Node();
    10.         Node firstNode3 = new Node();
    11.         List first = new ArrayList<>(Arrays.asList(firstNode1,firstNode2,firstNode3));
    12.  
    13.         //二级节点
    14.         Node sec1First1 = new Node();
    15.         Node sec2First1 = new Node();
    16.         Node sec3First1 = new Node();
    17.         List second1 = new ArrayList<>(Arrays.asList(sec1First1,sec2First1,sec3First1));
    18.         firstNode1.setChild(second1);
    19.  
    20.         Node sec1First2 = new Node();
    21.         Node sec2First2 = new Node();
    22.         Node sec3First2 = new Node();
    23.         List second2 = new ArrayList<>(Arrays.asList(sec1First2,sec2First2,sec3First2));
    24.         firstNode2.setChild(second2);
    25.  
    26.         Node sec1First3 = new Node();
    27.         Node sec2First3 = new Node();
    28.         Node sec3First3 = new Node();
    29.         List second3 = new ArrayList<>(Arrays.asList(sec1First3,sec2First3,sec3First3));
    30.         firstNode3.setChild(second3);
    31.  
    32.         sort(first);
    33.  
    34.         System.out.println(first);
    35.     }
    36.  
    37.     public static void sort(List tree){
    38.         int i = 0;
    39.         for (Node o : tree) {
    40.             o.setSort(i++);
    41.             if(o.getChild()!=null){
    42.                 sort(o.getChild());
    43.             }
    44.         }
    45.     }
    46. }

     

    1. import java.util.List;
    2.  
    3. public class Node {
    4.     private Integer sort;
    5.     private List child;
    6.  
    7.     public Integer getSort() {
    8.         return sort;
    9.     }
    10.  
    11.     public void setSort(Integer sort) {
    12.         this.sort = sort;
    13.     }
    14.  
    15.     public List getChild() {
    16.         return child;
    17.     }
    18.  
    19.     public void setChild(List child) {
    20.         this.child = child;
    21.     }
    22. }

    v2.0版

    增加parentId

    1.     public static void main(String[] args) {
    2.         //一级节点
    3.         Node firstNode1 = new Node("0001");
    4.         Node firstNode2 = new Node("0002");
    5.         Node firstNode3 = new Node("0003");
    6.         List first = new ArrayList<>(Arrays.asList(firstNode1,firstNode2,firstNode3));
    7.  
    8.         //二级节点
    9.         Node sec1First1 = new Node("00010001");
    10.         Node sec2First1 = new Node("00010002");
    11.         Node sec3First1 = new Node("00010003");
    12.         List second1 = new ArrayList<>(Arrays.asList(sec1First1,sec2First1,sec3First1));
    13.         firstNode1.setChild(second1);
    14.  
    15.         Node sec1First2 = new Node("00020001");
    16.         Node sec2First2 = new Node("00020002");
    17.         Node sec3First2 = new Node("00020003");
    18.         List second2 = new ArrayList<>(Arrays.asList(sec1First2,sec2First2,sec3First2));
    19.         firstNode2.setChild(second2);
    20.  
    21.         Node sec1First3 = new Node("00030001");
    22.         Node sec2First3 = new Node("00030002");
    23.         Node sec3First3 = new Node("00030003");
    24.         List second3 = new ArrayList<>(Arrays.asList(sec1First3,sec2First3,sec3First3));
    25.         firstNode3.setChild(second3);
    26.  
    27.         sort(first, "0");
    28.  
    29.         System.out.println(first);
    30.     }
    31.     public static void sort(List tree,String parentId){
    32.         int i = 0;
    33.         for (Node o : tree) {
    34.             o.setSort(i++);
    35.             o.setParentId(parentId);
    36.             if(o.getChild()!=null){
    37.                 sort(o.getChild(),o.getId());
    38.             }
    39.         }
    40.     }
    1. public class Node {
    2.     public Node(String id){
    3.         this.id = id;
    4.     }
    5.     private Integer sort;
    6.     private List child;
    7.     private String id;
    8.     private String parentId;
    9. //省略了get set方法没写，自己测的时候记得加上
    10. }

    v3.0版

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

    1.     public static void main(String[] args) {
    2.         //省略前面的代码
    3.         //...
    4.         List result = new ArrayList<>();
    5.         sort(first, "0", result);
    6.         //将结果集保存到数据库
    7.         xxxMapper.saveOrUpdate(result);
    8.     }
    9.  
    10.     public static void sort(List tree,String parentId,List result){
    11.         int i = 0;
    12.         for (Node o : tree) {
    13.             o.setSort(i++);
    14.             o.setParentId(parentId);
    15.             if(o.getChild()!=null){
    16.                 sort(o.getChild(),o.getId(),result);
    17.             }
    18.             o.setChild(null);//递归走出来后就不需要child了
    19.             result.add(o);//将当前节点存到结果集里
    20.         }
    21.     }

    注意：为了避免意外发生，生产上记得加上深度，以防万一出现死循环导致栈溢出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 first = new ArrayList<>(Arrays.asList(firstNode1,firstNode2,firstNode3));

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

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

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

            sort(first);

            System.out.println(first);
        }

        public static void sort(List 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 result = new ArrayList<>();
            sort(first, "0", result);
            //将结果集保存到数据库
            xxxMapper.saveOrUpdate(result);
        }

        public static void sort(List tree,String parentId,List 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 child;
        private String id;
        private String parentId;
    //省略了get set方法没写，自己测的时候记得加上
    }

  • 相关阅读:
    手写一个民用Tomcat （05）
    uboot移植之DDR初始化参数更改
    HTTP与HTTPS：深度解析两种网络协议的工作原理、安全机制、性能影响与现代Web应用中的重要角色
    二维数组与指针（杰哥强化版）
    基于反演法的悬架控制
    11-3 Iterator迭代器接口
    python面向对象进阶-继承、多态
    Firefox修改缓存目录的方法
    Day43-Java基础之单元测试和注解
    【JUC】读写锁
  • 原文地址：https://blog.csdn.net/u011149152/article/details/134184186