用控制台实现学生管理系统

一、阅读需求分析

学生管理系统的需求文档：

学生管理系统
????????

需求:

????????采取控制台的方式去书写学生管理系统。

分析:
????????初始菜单:

"-------------欢迎来到学生管理系统--------------"

"1: 添加学生"
"2: 删除学生"
"3: 修改学生"
"4:查询学生"
"5: 退出"
"请输入您的选择:"

??????????学生类:

????????????????属性: id、姓名、年龄、家庭住址

? ? ? ? ? 添加功能:

????????????????键盘录入每一个学生信息并添加，需要满足以下要求:

• ??????? ?id唯一

? ? ? ? ? 删除功能:

????????????????键盘录入要删除的学生id，需要满足以下要求:

• ? ? ? ?? id存在删除
• ?????????id不存在，需要提示不存在，并回到初始菜单

? ? ? ? ? 修改功能:

????????????????键盘录入要修改的学生id，需要满足以下要求

• ????????id存在，继续录入其他信息
• ? ? ? ? id不存在，需要提示不存在，并回到初始菜单

? ? ? ? ? 查询功能:

????????打印所有的学生信息，需要满足以下要求

• 如果没有学生信息，提示:当前无学生信息，请添加后再查询
• 如果有学生信息，需要按照以下格式输出。(不用过于纠结对齐的问题)?

?业务流程图

业务流程图最好画一下，不要光在脑子里面想，后面的流程图会更复杂！注意：

一定要跟着需求文档自己画出项目流 程图，然后对照流程图自己来写代码，这样才能学到东西。

?

注意：有一点小细节，因为定义的id是String类型的，如果在运行时输入整型类型的数据，在第二次添加的时候还输入同样的整型数据例如2，他不会报错。具体可以看以下的相关信息。

equals()方法会比较两个对象的内存地址是否相同，即它们是否引用同一个对象。
如果希望比较对象的属性或其他内容，则需要在类中重写equals()方法，根据需要比较对象的属性值。
/*在重写equals()方法时，通常需要满足以下条件：
自反性：对于任意非空对象x，x.equals(x)应该返回true。
对称性：对于任意非空对象x和y，如果x.equals(y)返回true，则y.equals(x)也应该返回true。
传递性：对于任意非空对象x、y和z，如果x.equals(y)返回true，并且y.equals(z)返回true，则x.equals(z)也应该返回true。
一致性：对于任意非空对象x和y，多次调用x.equals(y)应该返回相同的结果，前提是x和y的属性没有改变。
非空性：对于任意非空对象x，x.equals(null)应该返回false。
因此，equals()方法的比较内容可以是对象的属性值、状态或其他内容，只要满足上述条件即可。*/?

?删除这部分代码是错误的 删除不了的，因为if(flag)后list.remove(id)是查不到集合中元素索引

?

二、最终代码的运行结果

三、完整代码

注意：因为有注释，所以部分地方代码显得有些凌乱，望理解。

import java.util.ArrayList;
import java.util.Scanner;

public class StudentSystem {
    public static void main(String[] args) {
        //创建一个集合
        ArrayList<Student> list = new ArrayList<>();
       loop: while(true) {
//loop表示循环的意思 是一个标号 相当于给外面的while循环起了个名字 只要符合标识符命名的规范就可以
            System.out.println("-------------欢迎来到学生管理系统--------------");
            System.out.println("1: 添加学生");
            System.out.println("2: 删除学生");
            System.out.println("3: 修改学生");
            System.out.println("4: 查询学生");
            System.out.println("5: 退出");
            System.out.println("请输入您的选择:");
            //键盘录入让用户选择
            Scanner sc = new Scanner(System.in);
            String choose = sc.next();
//不管用户写什么类型的值用next容错率更高，大不了把这种情况再写到switch当中
           /*1.当变量的值与 case 语句的值相等时，那么 case 语句之后的语句开始执行，直到 break 语句出现才会跳出 switch 语句。
           2.当遇到 break 语句时，switch 语句终止。程序跳转到 switch 语句后面的语句执行。case 语句不必须要包含 break 语句。
           如果没有 break 语句出现，程序会继续执行下一条 case 语句，直到出现 break 语句。*/
           /*3. 条件和动作之间用->连接，这时fall-through规则失效。匹配到的分支代码执行完后直接跳出，不会继续执行下面的case对应的代码。也就是不需要再为每一个分支写break了。
           程序更简洁清晰，也更符合人类的直觉。需要注意，为了保持向后兼容性，case条件后依然可以使用:，
           这时fall-through还是有效的，即不能省略原有的break。而一个switch结构里不能混用->和:，否则会有编译错误。
           4. 每一个->后面只允许接一个表达式、一个代码块、或者一个throw语句。这样在代码块中定义的局部变量，其作用域就限制在代码块中，而不是蔓延到整个switch结构。逻辑更加清楚了。*/
            switch (choose) {
                //case "1" -> System.out.println("添加学生");这种格式是jdk12的新特性
                case "1":addStudent(list);break;//这里括号中不写list会报错，因为没有把集合放进去，就会导致调用方法时候不知道去哪里增删改查
                case "2":deleteStudent(list);break;
                case "3":updateStudent(list);break;
                case "4":queryStudent(list);break;//将每一个的输出语句换成对应的方法
                case "5":{
                    System.out.println("退出");//case中代码超过两行就不是一个语句体了必须用{}括起来
                    break loop;//且此时的break因为被循环嵌套了只能跳出单层的循环 写了标号之后直接跳出外层循环
                    //System.exit(0);//停止虚拟机运行(点击idea右上角的x也是执行该语句，让所有的代码都结束) <--什么时候用
                }
                default: System.out.println("没有该选项");//此时写一部分测一部分，保证你写的每一部分都是对的
            }//此时想多次反复循环的进行操作，不止操作一次就停了将代码用while(true)包裹起来 快捷键选中ctrl+alt+t
        }
    }

    //将main的全部代码收起来写其他方法-->查询最简单只需要遍历一下就好了
    //添加学生-->添加到哪里？需要什么？集合要返回结果吗？要
    public static void addStudent(ArrayList<Student> list){
        //利用空参构造先创建学生对象
        Student s =new Student();//然后用set方法往每一个输入语句后将数据添加到对象中
        Scanner sc = new Scanner(System.in);
        while(true) {
            System.out.println("请输入要添加学生的id:");
            String id = sc.next();

            //调用唯一性方法(要在setId之前)
            boolean flag = contains(list, id);
            if (flag) {//表示已经存在，需要重新录入-->就需要这段代码重新走一遍，用while(true)包裹重新走
                System.out.println("id已经存在，请重新录入。");
            } else {//表示id不存在，可以继续使用
                s.setId(id);//传进去值之后跳出循环
                break;
            }
        }

        System.out.println("请输入要填加学生的姓名:");
        String name = sc.next();
        s.setName(name);
        System.out.println("请输入要填加学生的年龄:");
        int age = sc.nextInt();
        s.setAge(age);
        System.out.println("请输入要填加学生的家庭住址:");
        String address = sc.next();
        s.setAddress(address);
        //四个属性有了——》然后创建学生对象
        //Student s = new Student(id,name,age,address);这里还可以利用空参构写方法的在最上面
        //这时已经把学生信息添加到学生对象中了，然后需要把学生对象添加到集合中
        list.add(s);

        //添加完成后提示一下用户是否添加成功
        //因为使用的是ArrayList集合不管添加什么都是添加成功的
        System.out.println("学生信息添加成功!");
    }

    //删除学生-->从哪删除？
    public static void deleteStudent(ArrayList<Student> list){
        /*//利用空参构造先创建学生对象(这里不需要)后面直接可以用remove删除
        Student s =new Student();//然后用get方法获取数据从对象中删除*/
        //集合，id
        //键盘录入要删除学生的id
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入要删除学生的id:");
        String id = sc.next();//键盘输入的id
        //返回结果
        //boolean flag = contains(list, id);用getIndex方法 查询索引 返回一个index然后删除
        int index = getIndex(list, id);
        if (index >= 0){
            //存在
            // 则说明索引大于等于0(找索引)删除-->删除就是使得所有信息全部删除(list.remove()删除)
            list.remove(index);
            System.out.println("id为:"+id+"的学生删除成功");
        }else {
            //不存在，提示不存在，返回初始菜单
            System.out.println("该id不存在，删除失败，返回初始菜单。");
        }
        //System.out.println("删除成功！");
    }

    //修改学生-->在哪修改？-->先判断id存在-->查找对应索引--> 修改什么-->每一个元素都有可能被修改
    public static void updateStudent(ArrayList<Student> list){
        //键盘录入要修改的学生id，查找索引修改对象中的元素
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入需要修改的学生id");
        String id = sc.next();
        //判断id是否存在并返回索引
        int index = getIndex(list, id);
        //这里不能再按照这个逻辑写了，因为修改就好比重新添加，使用set将原来的数据覆盖就好了
        /*if(index >= 0){
            //存在，继续录入其他信息
        }else {
            //不存在，提示不存在，返回初始菜单
            System.out.println("该id不存在，返回初始菜单。");
        }*/
        if(index == -1){
            //说明不存在
            System.out.println("要修改的id"+id+"不存在，请重新输入");
            return;
        }
        //当代码执行到这里就说明 id是存在的 获取需要修改的学生对象
        Student stu = list.get(index);
        //获取了学生对象之后，键盘录入要修改的其他信息 因为id是已知的 但也可以修改
        System.out.println("请输入要修改的学生id");
        String newId = sc.next();
        stu.setId(newId);
        //其他信息同理
        System.out.println("请输入需要修改的学生姓名");
        String newName = sc.next();
        stu.setName(newName);
        System.out.println("请输入需要修改的学生年龄");
        int newAge = sc.nextInt();
        stu.setAge(newAge);
        System.out.println("请输入需要修改的学生家庭住址");
        String newAddress = sc.next();
        stu.setAddress(newAddress);
        //写到这里可以发现并不是学生信息的所以内容都需要修改 后续可以升级
        System.out.println("学生信息修改成功");
    }

    //查询学生-->在哪查询？-->创建一个集合
    public static void queryStudent(ArrayList<Student> list){
        System.out.println("查询学生");
        //写的时候一定不要自己想着写，要按照需求文档--》打印所有的学生信息 没有提示添加后查询，有就输出
        //没有学生信息就是长度为0
        if(list.size() == 0){
            System.out.println("当前无学生信息，请添加后再查询");
            return;//结束方法
        }
        //当代码执行到这里就说明集合中是有数据的 有就遍历-->先得到学生对象
        //System.out.println("id      "+"姓名   "+"年龄   "+"家庭住址 ");
        System.out.println("id\t\t姓名\t年龄\t家庭住址\t");//实现分开且对齐效果\t制表符 可以理解为长度可变的空格(原理:和\t前面的内容是相关的要补齐8个字符或者8的倍数)
        for (int i = 0; i < list.size(); i++) {
            //表头信息在循环外面打印
            Student stu = list.get(i);
            System.out.println(stu.getId()+"\t"+stu.getName()+"\t"+stu.getAge()+"\t"+stu.getAddress());
        }
    }//写完所有方法后修改switch语句 就不要输出语句了直接调用其对应的每一个方法


    //方法：判断id在集合中是否存在(用来判断添加时的唯一性)
    public static boolean contains(ArrayList<Student> list,String id){
        //判断是否存在就要遍历
        for (int i = 0; i < list.size(); i++) {
            //获取对象从集合中拿
            /*Student stu = list.get(i);
            String sid = stu.getId();
            if(sid.equals(id)){
                //存在，true
                return true;}*/
            /*if (list.get(i).getId().equals(id)){//要和集合中的id比较必须要这个参数
                return true;*/
            //return list.get(i).getId().equals(id);//这里由于后面删除id又写了一个查找索引的方法所以还可以直接调用个体Index方法，
            //如果返回的是i索引则return true   这样可以少写代码实现代码的复用性
            return getIndex(list, id) >= 0;

            //equals()方法会比较两个对象的内存地址是否相同，即它们是否引用同一个对象。
            // 如果希望比较对象的属性或其他内容，则需要在类中重写equals()方法，根据需要比较对象的属性值。
            /*在重写equals()方法时，通常需要满足以下条件：
            自反性：对于任意非空对象x，x.equals(x)应该返回true。
            对称性：对于任意非空对象x和y，如果x.equals(y)返回true，则y.equals(x)也应该返回true。
            传递性：对于任意非空对象x、y和z，如果x.equals(y)返回true，并且y.equals(z)返回true，则x.equals(z)也应该返回true。
            一致性：对于任意非空对象x和y，多次调用x.equals(y)应该返回相同的结果，前提是x和y的属性没有改变。
            非空性：对于任意非空对象x，x.equals(null)应该返回false。
            因此，equals()方法的比较内容可以是对象的属性值、状态或其他内容，只要满足上述条件即可。*/
            }
        //不存在false
        return false;
        }


        //定义一个方法，来查找索引
    public static int getIndex(ArrayList<Student> list,String id){
        //遍历
        for (int i = 0; i < list.size(); i++) {
            //要比较id首先要获取学生对象——》再获取id
            Student stu = list.get(i);//获取学生对象
            String sid = stu.getId();//获取id给sid再用sid调用equals方法与输入的id进行比较
            if (sid.equals(id)){
                return i;
            }
        }
        //不存在
        return -1;
    }

}

四、一份没有注释的代码

import java.util.ArrayList;
import java.util.Scanner;

public class StudentSystem {
    public static void main(String[] args) {
        //创建一个集合
        ArrayList<Student> list = new ArrayList<>();
       loop: while(true) {
            System.out.println("-------------欢迎来到学生管理系统--------------");
            System.out.println("1: 添加学生");
            System.out.println("2: 删除学生");
            System.out.println("3: 修改学生");
            System.out.println("4: 查询学生");
            System.out.println("5: 退出");
            System.out.println("请输入您的选择:");
            //键盘录入让用户选择
            Scanner sc = new Scanner(System.in);
            String choose = sc.next();
            switch (choose) {
                //case "1" -> System.out.println("添加学生");这种格式是jdk12的新特性
                case "1":addStudent(list);break;
                case "2":deleteStudent(list);break;
                case "3":updateStudent(list);break;
                case "4":queryStudent(list);break;//将每一个的输出语句换成对应的方法
                case "5":{
                    System.out.println("退出");
                    break loop;
                }
                default: System.out.println("没有该选项");/
            }
        }
    }

  
    public static void addStudent(ArrayList<Student> list){
        Student s =new Student();
        Scanner sc = new Scanner(System.in);
        while(true) {
            System.out.println("请输入要添加学生的id:");
            String id = sc.next(); 
            boolean flag = contains(list, id);
            if (flag) {
                System.out.println("id已经存在，请重新录入。");
            } else {
                s.setId(id);
                break;
            }
        }

        System.out.println("请输入要填加学生的姓名:");
        String name = sc.next();
        s.setName(name);
        System.out.println("请输入要填加学生的年龄:");
        int age = sc.nextInt();
        s.setAge(age);
        System.out.println("请输入要填加学生的家庭住址:");
        String address = sc.next();
        s.setAddress(address);
        list.add(s);
        System.out.println("学生信息添加成功!");
    }   
    public static void deleteStudent(ArrayList<Student> list){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入要删除学生的id:");
        String id = sc.next();//键盘输入的id
      
        int index = getIndex(list, id);
        if (index >= 0){
           
            list.remove(index);
            System.out.println("id为:"+id+"的学生删除成功");
        }else {
            
            System.out.println("该id不存在，删除失败，返回初始菜单。");
        }
       
    }
    
    public static void updateStudent(ArrayList<Student> list){
        
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入需要修改的学生id");
        String id = sc.next();
        int index = getIndex(list, id);
        if(index == -1){
            System.out.println("要修改的id"+id+"不存在，请重新输入");
            return;
        }
        Student stu = list.get(index);
        System.out.println("请输入要修改的学生id");
        String newId = sc.next();
        stu.setId(newId);
     
        System.out.println("请输入需要修改的学生姓名");
        String newName = sc.next();
        stu.setName(newName);
        System.out.println("请输入需要修改的学生年龄");
        int newAge = sc.nextInt();
        stu.setAge(newAge);
        System.out.println("请输入需要修改的学生家庭住址");
        String newAddress = sc.next();
        stu.setAddress(newAddress);
        System.out.println("学生信息修改成功");
    }

    public static void queryStudent(ArrayList<Student> list){
        System.out.println("查询学生");
      
        if(list.size() == 0){
            System.out.println("当前无学生信息，请添加后再查询");
            return;
        }
        System.out.println("id\t\t姓名\t年龄\t家庭住址\t");
        for (int i = 0; i < list.size(); i++) {  
            Student stu = list.get(i);            System.out.println(stu.getId()+"\t"+stu.getName()+"\t"+stu.getAge()+"\t"+stu.getAddress());
        }
    }

    public static boolean contains(ArrayList<Student> list,String id){
        for (int i = 0; i < list.size(); i++) {
            return getIndex(list, id) >= 0;
        return false;
        }

  
    public static int getIndex(ArrayList<Student> list,String id){

        for (int i = 0; i < list.size(); i++) {
         
            Student stu = list.get(i);
            String sid = stu.getId();
            if (sid.equals(id)){
                return i;
            }
        }
        return -1;
    }

}