1. 请完成学生管理系统中，以下功能需求的设计及实现：
   1. 请使用Java语言完成学生基本信息类的设计，学生基本信息包括：学号、姓名、出生年月、性别、第几届、班级、身份证号、照片、备注信息；

      public class Student {
          private String no;
          private String name;
          private String birthday;
          private int sex;
          private String grade;
          private String classNo;
          private String cardId;
          private String photo;
          private String desc;
      }

   2. 请设计并完成符合Restful风格的学生基本信息的创建、修改、删除服务接口（只需给出接口定义，不需内部实现）；

      @RestController 
      @RequestMapping(value="/student")
      public interface Restful {
          @RequestMapping(value="/create", method=RequestMethod.POST) 
          boolean createStudent(Student stu);
          @RequestMapping(value="/alter", method=RequestMethod.PUT)
          boolean alterStudent(Student stu);
          @RequestMapping(value="/delete", method=RequestMethod.DELETE)
          boolean deleteStudent(Student stu);
      }
   3. 请使用Ajax完成学生基本信息的创建功能（Jquery或axios）；
       
   4. 请设计学生学号生成模块逻辑，学号规则如下：第几届+班级+班级内部序号。

      public void setNo(String grade, String classNo, String number) {
          this.no = grade + classNo + number;
      }

2. 学生管理系统中包含以下表：
    

   学生表（student）

   字段名	描述
   sno	学号
   sname	姓名
   sex	性别
   age	年龄
   address	地址
   classno	班级号

        

   班级表（class）

   字段名	描述
   classno	班级号
   classname	班级名名称
   monitor	班长姓名

      

   选课表（sc）

   字段名	描述
   sno	学号
   cno	课程号
   score	成绩

   课程表（course）

   字段名	描述
   cno	课程号
   cname	课程名
   lecture	学时
   credit	学分

   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
    
   1. 请解释一下SQL的作用：
      SELECT cno,score FROM SC WHERE score = (SELECT MAX(score) FROM SC WHERE sno = (SELCT sno FROM student WHERE sname='B'))；
      
      查询学生姓名为B同学最高分课程的课程号和分数。
   2. 请给出该需求的SQL：查询选修了“数据库”课程且成绩超过该课程平均成绩学生的学号。
      
      SELECT sno FROM sc WHERE score > (SELECT avg(score) FROM sc WHERE cno = (SELECT cno From course WHERE cname='数据库'))；
3. 现有一组导航菜单数据List<Menu>，导航菜单的模型如下：菜单Id（id），菜单名称（name），父级菜单（parentId），访问地址（url），排序（orderNo），请将该组数据转换成树状结构，要求如下：
   1. 根据parentId的引用关系，将菜单放到对应父菜单的children中，children定义为：List<Menu>
       

      package com.ch1;
      
      import java.util.List;
      
      public class Menu {
          private String id;
          private String name;
          private String parentId;
          private String url;
          private String orderNo;
          private List<Menu> children;
      
          public String getId() {
              return id;
          }
      
          public void setId(String id) {
              this.id = id;
          }
      
          public String getName() {
              return name;
          }
      
          public void setName(String name) {
              this.name = name;
          }
      
          public String getParentId() {
              return parentId;
          }
      
          public void setParentId(String parentId) {
              this.parentId = parentId;
          }
      
          public String getUrl() {
              return url;
          }
      
          public void setUrl(String url) {
              this.url = url;
          }
      
          public String getOrderNo() {
              return orderNo;
          }
      
          public void setOrderNo(String orderNo) {
              this.orderNo = orderNo;
          }
      
          public List<Menu> getChildren() {
              return children;
          }
      
          public void setChildren(List<Menu> children) {
              this.children = children;
          }
      }
      

   2. children属性内的数据要求按orderNo从小到大进行排序。
       

      package com.ch1;
      
      import org.apache.commons.lang.StringUtils;
      
      import java.util.ArrayList;
      import java.util.HashMap;
      import java.util.List;
      import java.util.Map;
      
      
      public class MenuDemo {
      
              private  static  List<Menu> getChild(String id, List<Menu> rootMenu) {
      
                  List<Menu> childList = new ArrayList<>();//存放直接子菜单
                  /**
                   *开始遍历二级菜单以及它的直接子菜单
                   */
                  for (Menu menu : rootMenu) {
                      // 遍历所有节点，将父菜单id与传过来的id比较
                      if (StringUtils.isNotBlank(menu.getParentId())) {//导入org.apache.commons.lang3.StringUtils;
                          if (id.equals(menu.getParentId())) {//尽量让id 在前面，因为他不会为空（数据库设计为主键），parentId 不一定都有值。
                              childList.add(menu);//相等的话说明这些使它（id）的直接子节点,加入childList
                          }
                      }
                  }//这时候已经将一级菜单以及一级的直接子孩子遍历出来了。
      
                  /**
                   * 把子菜单的直接子菜单再循环一遍
                   * 这时候就是从Menu的直接子菜单中获得需要遍历的菜单也就是childList
                   */
                  for (Menu menu : childList) {
                      if (StringUtils.isBlank(menu.getUrl())) {//这个判断的意思是 如果url 不为空说明是最后一个节点，为空说明他不是最后一个子节点，这时候就需要去遍历
                          menu.setChildren(getChild(menu.getId(), rootMenu));//递归
                      }
                  }
                  if (childList.size() == 0) {// 递归退出条件（走到这里childList 大小等于0 说明该节点就是最后一个）
                      return null;
                  }
                  return childList;
              }
              public static void main(String[] args) {
                  List<Menu> rootMenus =  new ArrayList<Menu>();//假设是从数据库查出来的
                  List<Menu> menuList = new ArrayList<Menu>();
                  /**
                   * 先找到所有的一级菜单
                   */
                  for (int i = 0; i < rootMenus.size(); i++) {
                      if (StringUtils.isBlank(rootMenus.get(i).getParentId()) || "0".equals(rootMenus.get(i).getParentId())) {// 一级菜单没有parentId （或是等于0，看怎么数据库怎么设置）
                          menuList.add(rootMenus.get(i));
                      }
                  }
                  /**
                   * 一级菜单之后，开始递归子菜单
                   */
                  for (Menu menu : menuList) {
                      menu.setChildren(getChild(menu.getId(), rootMenus));
                  }
                  Map<String,Object> jsonMap = new HashMap<>();
                  jsonMap.put("menu", menuList);
                  System.out.println(new Gson().toJson(jsonMap));//json 字符串 前端遍历
          }
      }
      

4. 有一组数据0,1,2,3...9，请完成函数，要求每次调用该函数，得到的数据排序都不一样。

   public class Demo {
       int array[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
   
       private void sort() {
           Set<Integer> arrSet = new HashSet<Integer>();
           for (int i = 0; i < 9; i++) {
               arrSet.add(array[i]);
           }
           Iterator<Integer> integerIterator = arrSet.iterator();
           while (integerIterator.hasNext()) {
               System.out.println(integerIterator.next());
           }
       }
   
       public static void main(String[] args) {
           Demo demo = new Demo();
           demo.sort();
       }
   }

5. 一个文本文件中包含以下数据：[{title:"数据5",order:5},{title:"数据3",order:3},...]请完成文件的的读取并将包含的数据按order字段排序后输出到控制台（可选用熟悉的工具类进行处理）。

package com.ch1;

import jdk.nashorn.internal.parser.JSONParser;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;

import java.io.*;
import java.util.Comparator;

public class ReadJson {

    public static void main(String[] args) {
        String path = "D:/web/test.txt";
        try {
            //文件读取
            Reader reader = new FileReader(path);
            BufferedReader bufferedReader = new BufferedReader(reader);
            String s = bufferedReader.readLine();
            //对象转换
            JSONArray jsonArray = JSONArray.fromObject(s);
            //排序
            System.out.println("排序前：");
            System.out.println(jsonArray);
            jsonArray.sort(Comparator.comparing(obj -> ((JSONObject) obj).getInt("order")));
            System.out.println("排序后");
            System.out.println(jsonArray);
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

 运行后：