学生管理系统案例

电玩女神 2024-04-17 06:22 187阅读 0赞

学生管理系统案例

1学生管理系统案例需求

在这里插入图片描述
利用集合完成对学生的增删改查四个功能

2学生管理系统案例实现

1创建学生类

  1. package com.igeek_02_01;
  3. /**  
  4. * @ClassName: Student  
  5. * @Description: 学生类
  6. * @date 2017年10月14日 上午10:35:59    
  7. * Company www.igeekhome.com
  8. *    
  9. */
  10. public class Student {
  11.     /**  
  12.     * @Fields id : 学号  
  13.     */  
  14.     private String id;
  15.     /**  
  16.     * @Fields name : 姓名  
  17.     */  
  18.     private String name;
  19.     /**  
  20.     * @Fields age : 年龄  
  21.     */  
  22.     private String age;
  23.     /**  
  24.     * @Fields address : 居住地  
  25.     */  
  26.     private String address;
  27.     /**  
  28.     * @Title: Student      
  29.     */
  30.     public Student() {
  31.     }
  32.     /**  
  33.     * @Title: Student  
  34.     * @param id
  35.     * @param name
  36.     * @param age
  37.     * @param address    
  38.     */
  39.     public Student(String id, String name, String age, String address) {
  40.         this.id = id;
  41.         this.name = name;
  42.         this.age = age;
  43.         this.address = address;
  44.     }
  45.     /**
  46.      * @return the id
  47.      */
  48.     public String getId() {
  49.         return id;
  50.     }
  51.     /**
  52.      * @param id the id to set
  53.      */
  54.     public void setId(String id) {
  55.         this.id = id;
  56.     }
  57.     /**
  58.      * @return the name
  59.      */
  60.     public String getName() {
  61.         return name;
  62.     }
  63.     /**
  64.      * @param name the name to set
  65.      */
  66.     public void setName(String name) {
  67.         this.name = name;
  68.     }
  69.     /**
  70.      * @return the age
  71.      */
  72.     public String getAge() {
  73.         return age;
  74.     }
  75.     /**
  76.      * @param age the age to set
  77.      */
  78.     public void setAge(String age) {
  79.         this.age = age;
  80.     }
  81.     /**
  82.      * @return the address
  83.      */
  84.     public String getAddress() {
  85.         return address;
  86.     }
  87.     /**
  88.      * @param address the address to set
  89.      */
  90.     public void setAddress(String address) {
  91.         this.address = address;
  92.     }
  94. }
  96. package com.igeek_02_01;
  98. /**  
  99. * @ClassName: StudentManagerTest  
  100. * @Description: 学生管理系统的主类
  101. * @date 2017年10月14日 上午10:35:59    
  102. * Company www.igeekhome.com
  103. *    
  104. *    这是我的学生管理系统的主类
  105. *    
  106. *    步骤如下：
  107. *        A：定义学生类
  108. *        B：学生管理系统的主界面的代码编写
  109. *        C：学生管理系统的查看所有学生的代码编写
  110. *        D：学生管理系统的添加学生的代码编写
  111. *        E：学生管理系统的删除学生的代码编写
  112. *        F：学生管理系统的修改学生的代码编写
  113. *    
  114. */
  115. public class StudentManagerTest {
  117. }

2学生管理系统界面实现

  1. package com.igeek_02_02;
  3. import java.util.ArrayList;
  4. import java.util.Scanner;
  6. /**  
  7.  * @ClassName: StudentManagerTest  
  8.  * @Description: 学生管理系统的主类
  9.  * @date 2017年10月14日 上午10:50:19    
  10.  * Company www.igeekhome.com
  11.  *    
  12.  * 这是我的学生管理系统的主类
  13.  * 
  14.  * 步骤如下：
  15.  * A:定义学生类
  16.  * B:学生管理系统的主界面的代码编写
  17.  * C:学生管理系统的查看所有学生的代码编写
  18.  * D:学生管理系统的添加学生的代码编写
  19.  * E:学生管理系统的删除学生的代码编写
  20.  * F:学生管理系统的修改学生的代码编写
  21.  */
  22. public class StudentManagerTest {
  23.     public static void main(String[] args) {
  25.         // 为了让程序能够回到这里来，我们使用循环
  26.         while (true) {
  27.             // 这是学生管理系统的主界面
  28.             System.out.println("--------欢迎来到学生管理系统--------");
  29.             System.out.println("1 查看所有学生");
  30.             System.out.println("2 添加学生");
  31.             System.out.println("3 删除学生");
  32.             System.out.println("4 修改学生");
  33.             System.out.println("5 退出");
  34.             System.out.println("请输入你的选择：");
  35.             // 创建键盘录入对象
  36.             Scanner sc = new Scanner(System.in);
  37.             String choiceString = sc.nextLine();
  38.             // 用switch语句实现选择
  39.             switch (choiceString) {
  40.             case "1":
  41.                 // 查看所有学生
  42.                 break;
  43.             case "2":
  44.                 // 添加学生
  45.                 break;
  46.             case "3":
  47.                 // 删除学生
  48.                 break;
  49.             case "4":
  50.                 // 修改学生
  51.                 break;
  52.             case "5":
  53.                 // 退出
  54.                 // System.out.println("谢谢你的使用");
  55.                 // break;
  56.             default:
  57.                 System.out.println("谢谢你的使用");
  58.                 System.exit(0); // JVM退出
  59.                 break;
  60.             }
  61.         }
  62.     }
  63. }

3学生管理系统之查询所有学生功能

  1. package com.igeek_02_03;
  3. import java.util.ArrayList;
  4. import java.util.Scanner;
  6. /**  
  7.  * @ClassName: StudentManagerTest  
  8.  * @Description: 学生管理系统的主类
  9.  * @date 2017年10月14日 上午10:50:19    
  10.  * Company www.igeekhome.com
  11.  *    
  12.  * 这是我的学生管理系统的主类
  13.  * 
  14.  * 步骤如下：
  15.  * A:定义学生类
  16.  * B:学生管理系统的主界面的代码编写
  17.  * C:学生管理系统的查看所有学生的代码编写
  18.  * D:学生管理系统的添加学生的代码编写
  19.  * E:学生管理系统的删除学生的代码编写
  20.  * F:学生管理系统的修改学生的代码编写
  21.  */
  22. public class StudentManagerTest {
  23.     public static void main(String[] args) {
  24.         // 创建集合对象，用于存储学生数据
  25.         ArrayList<Student> array = new ArrayList<Student>();
  27.         // 为了让程序能够回到这里来，我们使用循环
  28.         while (true) {
  29.             // 这是学生管理系统的主界面
  30.             System.out.println("--------欢迎来到学生管理系统--------");
  31.             System.out.println("1 查看所有学生");
  32.             System.out.println("2 添加学生");
  33.             System.out.println("3 删除学生");
  34.             System.out.println("4 修改学生");
  35.             System.out.println("5 退出");
  36.             System.out.println("请输入你的选择：");
  37.             // 创建键盘录入对象
  38.             Scanner sc = new Scanner(System.in);
  39.             String choiceString = sc.nextLine();
  40.             // 用switch语句实现选择
  41.             switch (choiceString) {
  42.             case "1":
  43.                 // 查看所有学生
  44.                 findAllStudent(array);
  45.                 break;
  46.             case "2":
  47.                 // 添加学生
  48.                 break;
  49.             case "3":
  50.                 // 删除学生
  51.                 break;
  52.             case "4":
  53.                 // 修改学生
  54.                 break;
  55.             case "5":
  56.                 // 退出
  57.                 // System.out.println("谢谢你的使用");
  58.                 // break;
  59.             default:
  60.                 System.out.println("谢谢你的使用");
  61.                 System.exit(0); // JVM退出
  62.                 break;
  63.             }
  64.         }
  65.     }
  67.     /**  
  68.     * @Title: findAllStudent  
  69.     * @Description: 查看所有学生  
  70.     * @param array    
  71.     */
  72.     public static void findAllStudent(ArrayList<Student> array) {
  73.         //首先来判断集合中是否有数据，如果没有数据，就给出提示，并让该方法不继续往下执行
  74.         if(array.size() == 0) {
  75.             System.out.println("不好意思,目前没有学生信息可供查询,请回去重新选择你的操作");
  76.             return;
  77.         }
  79.         //\t 其实就是一个tab键的位置
  80.         System.out.println("学号\t姓名\t年龄\t居住地");
  81.         for(int x=0; x<array.size(); x++) {
  82.             Student s = array.get(x);
  83.             System.out.println(s.getId()+"\t"+s.getName()+"\t"+s.getAge()+"\t"+s.getAddress());
  84.         }
  85.     }
  87. }

4学生管理系统之添加学生功能

  1. package com.igeek_02_04;
  3. import java.util.ArrayList;
  4. import java.util.Scanner;
  6. /**  
  7.  * @ClassName: StudentManagerTest  
  8.  * @Description: 学生管理系统的主类
  9.  * @date 2017年10月14日 上午10:50:19    
  10.  * Company www.igeekhome.com
  11.  *    
  12.  * 这是我的学生管理系统的主类
  13.  * 
  14.  * 步骤如下：
  15.  * A:定义学生类
  16.  * B:学生管理系统的主界面的代码编写
  17.  * C:学生管理系统的查看所有学生的代码编写
  18.  * D:学生管理系统的添加学生的代码编写
  19.  * E:学生管理系统的删除学生的代码编写
  20.  * F:学生管理系统的修改学生的代码编写
  21.  */
  22. public class StudentManagerTest {
  23.     public static void main(String[] args) {
  24.         // 创建集合对象，用于存储学生数据
  25.         ArrayList<Student> array = new ArrayList<Student>();
  27.         // 为了让程序能够回到这里来，我们使用循环
  28.         while (true) {
  29.             // 这是学生管理系统的主界面
  30.             System.out.println("--------欢迎来到学生管理系统--------");
  31.             System.out.println("1 查看所有学生");
  32.             System.out.println("2 添加学生");
  33.             System.out.println("3 删除学生");
  34.             System.out.println("4 修改学生");
  35.             System.out.println("5 退出");
  36.             System.out.println("请输入你的选择：");
  37.             // 创建键盘录入对象
  38.             Scanner sc = new Scanner(System.in);
  39.             String choiceString = sc.nextLine();
  40.             // 用switch语句实现选择
  41.             switch (choiceString) {
  42.             case "1":
  43.                 // 查看所有学生
  44.                 findAllStudent(array);
  45.                 break;
  46.             case "2":
  47.                 // 添加学生
  48.                 addStudent(array);
  49.                 break;
  50.             case "3":
  51.                 // 删除学生
  52.                 break;
  53.             case "4":
  54.                 // 修改学生
  55.                 break;
  56.             case "5":
  57.                 // 退出
  58.                 // System.out.println("谢谢你的使用");
  59.                 // break;
  60.             default:
  61.                 System.out.println("谢谢你的使用");
  62.                 System.exit(0); // JVM退出
  63.                 break;
  64.             }
  65.         }
  66.     }
  68.     /*
  69.     //添加学生
  70.     public static void addStudent(ArrayList<Student> array) {
  71.         //创建键盘录入对象
  72.         Scanner sc = new Scanner(System.in);
  74.         System.out.println("请输入学生学号：");
  75.         String id = sc.nextLine();
  76.         System.out.println("请输入学生姓名：");
  77.         String name = sc.nextLine();
  78.         System.out.println("请输入学生年龄：");
  79.         String age = sc.nextLine();
  80.         System.out.println("请输入学生居住地：");
  81.         String address = sc.nextLine();
  83.         //创建学生对象
  84.         Student s = new Student();
  85.         s.setId(id);
  86.         s.setName(name);
  87.         s.setAge(age);
  88.         s.setAddress(address);
  90.         //把学生对象作为元素添加到集合
  91.         array.add(s);
  93.         //给出提示
  94.         System.out.println("添加学生成功");
  95.     }
  96.     */
  98.     /**  
  99.     * @Title: addStudent  
  100.     * @Description: 添加学生  
  101.     * @param array    
  102.     */
  103.     public static void addStudent(ArrayList<Student> array) {
  104.         //创建键盘录入对象
  105.         Scanner sc = new Scanner(System.in);
  107.         //为了让id能够被访问到，我们就把id定义在了循环的外面
  108.         String id;
  110.         //为了让代码能够回到这里，用循环
  111.         while(true) {
  112.             System.out.println("请输入学生学号：");
  113.             //String id = sc.nextLine();
  114.             id = sc.nextLine();
  116.             //判断学号有没有被人占用
  117.             //定义标记
  118.             boolean flag = false;
  119.             //遍历集合，得到每一个学生
  120.             for(int x=0; x<array.size(); x++) {
  121.                 Student s = array.get(x);
  122.                 //获取该学生的学号，和键盘录入的学号进行比较
  123.                 if(s.getId().equals(id)) {
  124.                     flag = true; //说明学号被占用了
  125.                     break;
  126.                 }
  127.             }
  129.             if(flag) {
  130.                 System.out.println("你输入的学号已经被占用,请重新输入");
  131.             }else {
  132.                 break; //结束循环
  133.             }
  134.         }
  136.         System.out.println("请输入学生姓名：");
  137.         String name = sc.nextLine();
  138.         System.out.println("请输入学生年龄：");
  139.         String age = sc.nextLine();
  140.         System.out.println("请输入学生居住地：");
  141.         String address = sc.nextLine();
  143.         //创建学生对象
  144.         Student s = new Student();
  145.         s.setId(id);
  146.         s.setName(name);
  147.         s.setAge(age);
  148.         s.setAddress(address);
  150.         //把学生对象作为元素添加到集合
  151.         array.add(s);
  153.         //给出提示
  154.         System.out.println("添加学生成功");
  155.     }
  156. }

5学生管理系统之删除学生功能

  1. package com.igeek_02_05;
  3. import java.util.ArrayList;
  4. import java.util.Scanner;
  6. /**  
  7.  * @ClassName: StudentManagerTest  
  8.  * @Description: 学生管理系统的主类
  9.  * @date 2017年10月14日 上午10:50:19    
  10.  * Company www.igeekhome.com
  11.  *    
  12.  * 这是我的学生管理系统的主类
  13.  * 
  14.  * 步骤如下：
  15.  * A:定义学生类
  16.  * B:学生管理系统的主界面的代码编写
  17.  * C:学生管理系统的查看所有学生的代码编写
  18.  * D:学生管理系统的添加学生的代码编写
  19.  * E:学生管理系统的删除学生的代码编写
  20.  * F:学生管理系统的修改学生的代码编写
  21.  */
  22. public class StudentManagerTest {
  23.     public static void main(String[] args) {
  24.         // 创建集合对象，用于存储学生数据
  25.         ArrayList<Student> array = new ArrayList<Student>();
  27.         // 为了让程序能够回到这里来，我们使用循环
  28.         while (true) {
  29.             // 这是学生管理系统的主界面
  30.             System.out.println("--------欢迎来到学生管理系统--------");
  31.             System.out.println("1 查看所有学生");
  32.             System.out.println("2 添加学生");
  33.             System.out.println("3 删除学生");
  34.             System.out.println("4 修改学生");
  35.             System.out.println("5 退出");
  36.             System.out.println("请输入你的选择：");
  37.             // 创建键盘录入对象
  38.             Scanner sc = new Scanner(System.in);
  39.             String choiceString = sc.nextLine();
  40.             // 用switch语句实现选择
  41.             switch (choiceString) {
  42.             case "1":
  43.                 //查看所有学生
  44.                 findAllStudent(array);
  45.                 break;
  46.             case "2":
  47.                 //添加学生
  48.                 addStudent(array);
  49.                 break;
  50.             case "3":
  51.                 //删除学生
  52.                 deleteStudent(array);
  53.                 break;
  54.             case "4":
  55.                 // 修改学生
  56.                 break;
  57.             case "5":
  58.                 // 退出
  59.                 // System.out.println("谢谢你的使用");
  60.                 // break;
  61.             default:
  62.                 System.out.println("谢谢你的使用");
  63.                 System.exit(0); // JVM退出
  64.                 break;
  65.             }
  66.         }
  67.     }
  69.     /**  
  70.     * @Title: deleteStudent  
  71.     * @Description: 删除学生 
  72.     * @param array    
  73.     */
  74.     public static void deleteStudent(ArrayList<Student> array) {
  75.         //删除学生的思路：键盘录入一个学号，到集合中去查找，看是否有学生使用的是该学号，如果有就删除该学生
  76.         //创建键盘录入对象
  77.         Scanner sc = new Scanner(System.in);
  78.         System.out.println("请输入你要删除的学生的学号：");
  79.         String id = sc.nextLine();
  81.         /*
  82.         //遍历集合
  83.         for(int x=0; x<array.size(); x++) {
  84.             //获取到每一个学生对象
  85.             Student s = array.get(x);
  86.             //拿这个学生对象的学号和键盘录入的学号进行比较
  87.             if(s.getId().equals(id)) {
  88.                 array.remove(x); //根据索引删除
  89.                 break;
  90.             }
  91.         }
  93.         //给出提示
  94.         System.out.println("删除学生成功");
  95.         */
  97.         //我们必须给出学号不存在的时候的提示
  99.         //定义一个索引
  100.         int index = -1;
  102.         //遍历集合
  103.         for(int x=0; x<array.size(); x++) {
  104.             //获取到每一个学生对象
  105.             Student s = array.get(x);
  106.             //拿这个学生对象的学号和键盘录入的学号进行比较
  107.             if(s.getId().equals(id)) {
  108.                 index = x;
  109.                 break;
  110.             }
  111.         }
  113.         if(index == -1) {
  114.             System.out.println("不好意思,你要删除的学号对应的学生信息不存在,请回去重新你的选择");
  115.         }else {
  116.             array.remove(index);
  117.             System.out.println("删除学生成功");
  118.         }
  120.     }
  121. }

6学生管理系统之修改学生功能

  1. package com.igeek_02_06;
  3. import java.util.ArrayList;
  4. import java.util.Scanner;
  6. /**  
  7.  * @ClassName: StudentManagerTest  
  8.  * @Description: 学生管理系统的主类
  9.  * @date 2017年10月14日 上午10:50:19    
  10.  * Company www.igeekhome.com
  11.  *    
  12.  * 这是我的学生管理系统的主类
  13.  * 
  14.  * 步骤如下：
  15.  * A:定义学生类
  16.  * B:学生管理系统的主界面的代码编写
  17.  * C:学生管理系统的查看所有学生的代码编写
  18.  * D:学生管理系统的添加学生的代码编写
  19.  * E:学生管理系统的删除学生的代码编写
  20.  * F:学生管理系统的修改学生的代码编写
  21.  */
  22. public class StudentManagerTest {
  23.     public static void main(String[] args) {
  24.         // 创建集合对象，用于存储学生数据
  25.         ArrayList<Student> array = new ArrayList<Student>();
  27.         // 为了让程序能够回到这里来，我们使用循环
  28.         while (true) {
  29.             // 这是学生管理系统的主界面
  30.             System.out.println("--------欢迎来到学生管理系统--------");
  31.             System.out.println("1 查看所有学生");
  32.             System.out.println("2 添加学生");
  33.             System.out.println("3 删除学生");
  34.             System.out.println("4 修改学生");
  35.             System.out.println("5 退出");
  36.             System.out.println("请输入你的选择：");
  37.             // 创建键盘录入对象
  38.             Scanner sc = new Scanner(System.in);
  39.             String choiceString = sc.nextLine();
  40.             // 用switch语句实现选择
  41.             switch (choiceString) {
  42.             case "1":
  43.                 // 查看所有学生
  44.                 findAllStudent(array);
  45.                 break;
  46.             case "2":
  47.                 //添加学生
  48.                 addStudent(array);
  49.                 break;
  50.             case "3":
  51.                 //删除学生
  52.                 deleteStudent(array);
  53.                 break;
  54.             case "4":
  55.                 // 修改学生
  56.                 updateStudent(array);
  57.                 break;
  58.             case "5":
  59.                 // 退出
  60.                 // System.out.println("谢谢你的使用");
  61.                 // break;
  62.             default:
  63.                 System.out.println("谢谢你的使用");
  64.                 System.exit(0); // JVM退出
  65.                 break;
  66.             }
  67.         }
  68.     }
  70.     /**  
  71.     * @Title: updateStudent  
  72.     * @Description: 修改学生  
  73.     * @param array    
  74.     */
  75.     public static void updateStudent(ArrayList<Student> array) {
  76.         //修改学生的思路：键盘录入一个学号，到集合中去查找，看是否有学生使用的是该学号，如果有就修改该学生
  77.         //创建键盘录入对象
  78.         Scanner sc = new Scanner(System.in);
  79.         System.out.println("请输入你要修改的学生的学号：");
  80.         String id = sc.nextLine();
  82.         //定义一个索引
  83.         int index = -1;
  85.         //遍历集合
  86.         for(int x=0; x<array.size(); x++) {
  87.             //获取每一个学生对象
  88.             Student s = array.get(x);
  89.             //拿学生对象的学号和键盘录入的学号进行比较
  90.             if(s.getId().equals(id)) {
  91.                 index = x;
  92.                 break;
  93.             }
  94.         }
  96.         if(index == -1) {
  97.             System.out.println("不好意思,你要修改的学号对应的学生信息不存在,请回去重新你的选择");
  98.         }else {
  99.             System.out.println("请输入学生新姓名：");
  100.             String name = sc.nextLine();
  101.             System.out.println("请输入学生新年龄：");
  102.             String age = sc.nextLine();
  103.             System.out.println("请输入学生新居住地：");
  104.             String address = sc.nextLine();
  106.             //创建学生对象
  107.             Student s = new Student();
  108.             s.setId(id);
  109.             s.setName(name);
  110.             s.setAge(age);
  111.             s.setAddress(address);
  113.             //修改集合中的学生对象
  114.             array.set(index, s);
  116.             //给出提示
  117.             System.out.println("修改学生成功");
  118.         }
  119.     }
  120. }

3学生管理系统最终完整代码

  1. package com.igeek_03;
  3. import java.util.ArrayList;
  4. import java.util.Scanner;
  6. /**  
  7.  * @ClassName: StudentManagerTest  
  8.  * @Description: 学生管理系统的主类
  9.  * @date 2017年10月14日 上午10:50:19    
  10.  * Company www.igeekhome.com
  11.  *    
  12.  * 这是我的学生管理系统的主类
  13.  * 
  14.  * 步骤如下：
  15.  * A:定义学生类
  16.  * B:学生管理系统的主界面的代码编写
  17.  * C:学生管理系统的查看所有学生的代码编写
  18.  * D:学生管理系统的添加学生的代码编写
  19.  * E:学生管理系统的删除学生的代码编写
  20.  * F:学生管理系统的修改学生的代码编写
  21.  */
  22. public class StudentManagerTest {
  23.     public static void main(String[] args) {
  24.         // 创建集合对象，用于存储学生数据
  25.         ArrayList<Student> array = new ArrayList<Student>();
  27.         // 为了让程序能够回到这里来，我们使用循环
  28.         while (true) {
  29.             // 这是学生管理系统的主界面
  30.             System.out.println("--------欢迎来到学生管理系统--------");
  31.             System.out.println("1 查看所有学生");
  32.             System.out.println("2 添加学生");
  33.             System.out.println("3 删除学生");
  34.             System.out.println("4 修改学生");
  35.             System.out.println("5 退出");
  36.             System.out.println("请输入你的选择：");
  37.             // 创建键盘录入对象
  38.             Scanner sc = new Scanner(System.in);
  39.             String choiceString = sc.nextLine();
  40.             // 用switch语句实现选择
  41.             switch (choiceString) {
  42.             case "1":
  43.                 // 查看所有学生
  44.                 findAllStudent(array);
  45.                 break;
  46.             case "2":
  47.                 // 添加学生
  48.                 addStudent(array);
  49.                 break;
  50.             case "3":
  51.                 // 删除学生
  52.                 deleteStudent(array);
  53.                 break;
  54.             case "4":
  55.                 // 修改学生
  56.                 updateStudent(array);
  57.                 break;
  58.             case "5":
  59.                 // 退出
  60.                 // System.out.println("谢谢你的使用");
  61.                 // break;
  62.             default:
  63.                 System.out.println("谢谢你的使用");
  64.                 System.exit(0); // JVM退出
  65.                 break;
  66.             }
  67.         }
  68.     }
  70.     /**  
  71.     * @Title: findAllStudent  
  72.     * @Description: 查看所有学生  
  73.     * @param array    
  74.     */
  75.     public static void findAllStudent(ArrayList<Student> array) {
  76.         //首先来判断集合中是否有数据，如果没有数据，就给出提示，并让该方法不继续往下执行
  77.         if(array.size() == 0) {
  78.             System.out.println("不好意思,目前没有学生信息可供查询,请回去重新选择你的操作");
  79.             return;
  80.         }
  82.         //\t 其实就是一个tab键的位置
  83.         System.out.println("学号\t姓名\t年龄\t居住地");
  84.         for(int x=0; x<array.size(); x++) {
  85.             Student s = array.get(x);
  86.             System.out.println(s.getId()+"\t"+s.getName()+"\t"+s.getAge()+"\t"+s.getAddress());
  87.         }
  88.     }
  90.     /*
  91.     //添加学生
  92.     public static void addStudent(ArrayList<Student> array) {
  93.         //创建键盘录入对象
  94.         Scanner sc = new Scanner(System.in);
  96.         System.out.println("请输入学生学号：");
  97.         String id = sc.nextLine();
  98.         System.out.println("请输入学生姓名：");
  99.         String name = sc.nextLine();
  100.         System.out.println("请输入学生年龄：");
  101.         String age = sc.nextLine();
  102.         System.out.println("请输入学生居住地：");
  103.         String address = sc.nextLine();
  105.         //创建学生对象
  106.         Student s = new Student();
  107.         s.setId(id);
  108.         s.setName(name);
  109.         s.setAge(age);
  110.         s.setAddress(address);
  112.         //把学生对象作为元素添加到集合
  113.         array.add(s);
  115.         //给出提示
  116.         System.out.println("添加学生成功");
  117.     }
  118.     */
  120.     /**  
  121.     * @Title: addStudent  
  122.     * @Description: 添加学生  
  123.     * @param array    
  124.     */
  125.     public static void addStudent(ArrayList<Student> array) {
  126.         //创建键盘录入对象
  127.         Scanner sc = new Scanner(System.in);
  129.         //为了让id能够被访问到，我们就把id定义在了循环的外面
  130.         String id;
  132.         //为了让代码能够回到这里，用循环
  133.         while(true) {
  134.             System.out.println("请输入学生学号：");
  135.             //String id = sc.nextLine();
  136.             id = sc.nextLine();
  138.             //判断学号有没有被人占用
  139.             //定义标记
  140.             boolean flag = false;
  141.             //遍历集合，得到每一个学生
  142.             for(int x=0; x<array.size(); x++) {
  143.                 Student s = array.get(x);
  144.                 //获取该学生的学号，和键盘录入的学号进行比较
  145.                 if(s.getId().equals(id)) {
  146.                     flag = true; //说明学号被占用了
  147.                     break;
  148.                 }
  149.             }
  151.             if(flag) {
  152.                 System.out.println("你输入的学号已经被占用,请重新输入");
  153.             }else {
  154.                 break; //结束循环
  155.             }
  156.         }
  158.         System.out.println("请输入学生姓名：");
  159.         String name = sc.nextLine();
  160.         System.out.println("请输入学生年龄：");
  161.         String age = sc.nextLine();
  162.         System.out.println("请输入学生居住地：");
  163.         String address = sc.nextLine();
  165.         //创建学生对象
  166.         Student s = new Student();
  167.         s.setId(id);
  168.         s.setName(name);
  169.         s.setAge(age);
  170.         s.setAddress(address);
  172.         //把学生对象作为元素添加到集合
  173.         array.add(s);
  175.         //给出提示
  176.         System.out.println("添加学生成功");
  177.     }
  179.     /**  
  180.     * @Title: deleteStudent  
  181.     * @Description: 删除学生 
  182.     * @param array    
  183.     */
  184.     public static void deleteStudent(ArrayList<Student> array) {
  185.         //删除学生的思路：键盘录入一个学号，到集合中去查找，看是否有学生使用的是该学号，如果有就删除该学生
  186.         //创建键盘录入对象
  187.         Scanner sc = new Scanner(System.in);
  188.         System.out.println("请输入你要删除的学生的学号：");
  189.         String id = sc.nextLine();
  191.         /*
  192.         //遍历集合
  193.         for(int x=0; x<array.size(); x++) {
  194.             //获取到每一个学生对象
  195.             Student s = array.get(x);
  196.             //拿这个学生对象的学号和键盘录入的学号进行比较
  197.             if(s.getId().equals(id)) {
  198.                 array.remove(x); //根据索引删除
  199.                 break;
  200.             }
  201.         }
  203.         //给出提示
  204.         System.out.println("删除学生成功");
  205.         */
  207.         //我们必须给出学号不存在的时候的提示
  209.         //定义一个索引
  210.         int index = -1;
  212.         //遍历集合
  213.         for(int x=0; x<array.size(); x++) {
  214.             //获取到每一个学生对象
  215.             Student s = array.get(x);
  216.             //拿这个学生对象的学号和键盘录入的学号进行比较
  217.             if(s.getId().equals(id)) {
  218.                 index = x;
  219.                 break;
  220.             }
  221.         }
  223.         if(index == -1) {
  224.             System.out.println("不好意思,你要删除的学号对应的学生信息不存在,请回去重新你的选择");
  225.         }else {
  226.             array.remove(index);
  227.             System.out.println("删除学生成功");
  228.         }
  230.     }
  232.     /**  
  233.     * @Title: updateStudent  
  234.     * @Description: 修改学生  
  235.     * @param array    
  236.     */
  237.     public static void updateStudent(ArrayList<Student> array) {
  238.         //修改学生的思路：键盘录入一个学号，到集合中去查找，看是否有学生使用的是该学号，如果有就修改该学生
  239.         //创建键盘录入对象
  240.         Scanner sc = new Scanner(System.in);
  241.         System.out.println("请输入你要修改的学生的学号：");
  242.         String id = sc.nextLine();
  244.         //定义一个索引
  245.         int index = -1;
  247.         //遍历集合
  248.         for(int x=0; x<array.size(); x++) {
  249.             //获取每一个学生对象
  250.             Student s = array.get(x);
  251.             //拿学生对象的学号和键盘录入的学号进行比较
  252.             if(s.getId().equals(id)) {
  253.                 index = x;
  254.                 break;
  255.             }
  256.         }
  258.         if(index == -1) {
  259.             System.out.println("不好意思,你要修改的学号对应的学生信息不存在,请回去重新你的选择");
  260.         }else {
  261.             System.out.println("请输入学生新姓名：");
  262.             String name = sc.nextLine();
  263.             System.out.println("请输入学生新年龄：");
  264.             String age = sc.nextLine();
  265.             System.out.println("请输入学生新居住地：");
  266.             String address = sc.nextLine();
  268.             //创建学生对象
  269.             Student s = new Student();
  270.             s.setId(id);
  271.             s.setName(name);
  272.             s.setAge(age);
  273.             s.setAddress(address);
  275.             //修改集合中的学生对象
  276.             array.set(index, s);
  278.             //给出提示
  279.             System.out.println("修改学生成功");
  280.         }
  281.     }
  282. }

发表评论

表情：
评论列表 （有 0 条评论，187人围观）

还没有评论，来说两句吧...

相关阅读

    相关 学生管理系统

    我现在是大一新生！这个系统我写了一个月。但是还是不是很好。但是我想着是我的第一个系统。我在写的时候发现我的删除功能不是很好的。还有就是在这个过程中我学会了再这里我学到了如何使用

    比眉伴天荒比眉伴天荒/ 0 赞/ 376 阅读

    相关 学生管理系统

    注释：这个小的系统，主要体现了C语言的  “分而治之，代码重用”  也就是老师教函数时给我们说的最核心的思想。   主要吧，就是先在开始：定义后面要使用的函数，再定义一些全局变

    冷不防冷不防/ 0 赞/ 327 阅读