1.对象数组

1.1 对象数组概述

A:基本类型的数组:存储的元素为基本类型
int[] arr={1,2,3,4}
B:对象数组:存储的元素为引用类型
Student[] stus=new Student[3];
Student代表一个自定义类
stus数组中stus[0],stus[1],stus[2]的元素数据类型为Student,都可以指向一个Student对象

案例

  1. package com.igeek_03;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-11-25-14:21
  6.  */
  8. import sun.management.counter.perf.PerfInstrumentation;
  10. /**
  11.  * 数组：
  12.  * 基本类型的数组--int，char····
  13.  * 对象类型的数组--保存对象的数组--首先要有对象
  14.  *
  15.  * 当前这个学生类是一个实体类，用于后面的对象类型数组
  16.  */
  17. public class Student {
  18.     //属性
  19.     private String name;
  20.     private int age;
  22.     //构造函数
  23.     public Student() {
  24.     }
  26.     public Student(String name, int age) {
  27.         this.name = name;
  28.         this.age = age;
  29.     }
  31.     public String getName() {
  32.         return name;
  33.     }
  35.     public void setName(String name) {
  36.         this.name = name;
  37.     }
  39.     public int getAge() {
  40.         return age;
  41.     }
  43.     public void setAge(int age) {
  44.         this.age = age;
  45.     }
  47.     @Override
  48.     public String toString() {
  49.         return "Student{" +
  50.                 "name='" + name + '\'' +
  51.                 ", age=" + age +
  52.                 '}';
  53.     }
  54. }
  1. package com.igeek_03;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-11-25-14:25
  6.  */
  8. /**
  9.  * 创建对象类型的数组---对象就是学生--Student类型的数组
  10.  *
  11.  * 做以下几件事情
  12.  * 1.定义学生类
  13.  * 2.创建学生类型的数组
  14.  * 3.创建学生对象
  15.  * 4.把学生对象存放进数组
  16.  * 5.遍历学生数组
  17.  */
  18. public class StudentDemo {
  19.     public static void main(String[] args) {
  20.         //2.创建学生类型的数组
  21.         Student[] students=new Student[3];//长度为3
  22.         //取值
  23.         System.out.println(students[0]+" "+students[1]+" "+students[2]);
  24.         System.out.println("----------------------");
  26.         //把学生对象作为元素赋值给学生数组
  27.         students[0]=new Student("王嘉尔",27);
  28.         students[1]=new Student("王一博",23);
  29.         students[2]=new Student("王俊凯",22);
  30.         System.out.println(students[0]+" "+students[1]+" "+students[2]);
  31.         //Student{name='王嘉尔', age=27} Student{name='王一博', age=23} Student{name='王俊凯', age=22}
  34.         //遍历数组
  35.         for (int i = 0; i <students.length ; i++) {
  36.             //从数组中拿到一个学生对象就实例化
  37.             Student s=students[i];
  38.             System.out.println(s);
  39. //            System.out.println(students[i]);
  40.             System.out.println(s.getName()+" "+s.getAge());
  41.         }
  42.     }
  43. }

2.集合之ArrayList

Java中的集合：
其实集合与数组作用类似，就是用于同时保存和处理多个数据
 但是数组一旦声明长度，就无法改变；
集合可以自动的变换长度，更加的灵活，可以同时保持不同类型的数组
 —性能是次于数组的

 ArrayList是数组类型的集合//属于util包下的
特点：
 1.长度可变
2.可以保存不同类型的数据—前提是没有泛型

泛型：是jdk5.0版本推出的
 作用：为了规范集合保存数据的类型，可以使用泛型进行约束

ArrayList添加新元素

  1. package com.igeek_05;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-11-25-14:40
  6.  */
  8. import java.util.ArrayList;
  10. /**
  11.  * Java中的集合：
  12.  * 其实集合与数组作用类似，就是用于同时保存和处理多个数据
  13.  * 但是数组一旦声明长度，就无法改变；
  14.  * 集合可以自动的变换长度，更加的灵活，可以同时保持不同类型的数组
  15.  * --性能是次于数组的
  16.  *
  17.  * ArrayList是数组类型的集合//属于util包下的
  18.  * 特点：
  19.  * 1.长度可变
  20.  * 2.可以保存不同类型的数据--前提是没有泛型
  21.  *
  22.  * 泛型：是jdk5.0版本推出的
  23.  * 作用：为了规范集合保存数据的类型，可以使用泛型进行约束
  24.  */
  25. public class ArrayListDemo1 {
  26.     public static void main(String[] args) {
  27.         //演示集合的使用
  28.         //1.创建对象
  29.         ArrayList array=new ArrayList();
  30.         //2.添加数据--任意的数据--add()方法
  31.         array.add("Lynn");//String类型
  32.         array.add(18);//int类型
  33.         array.add(true);
  34.         array.add(3.1415926535);
  36.         //输出结果
  37.         System.out.println(array);
  39.         System.out.println("------------------");
  41.         //演示泛型的使用
  42.         ArrayList<String> list=new ArrayList<String>();
  43.         //添加数据
  44.         list.add("吴奇隆");
  45.         list.add("苏有朋");
  46.         list.add("陈志朋");
  47.         //list.add(123);//会报错，因为只能输出字符串类型
  48.         //输出
  49.         System.out.println(list);
  50.     }
  51. }

ArrayList删改查方法

A:获取元素
public E get(int index):返回指定索引处的元素
B:集合长度
public int size():返回集合中的元素的个数
C:删除元素
public boolean remove(Object o):删除指定的元素，返回删除是否成功
public E remove(int index):删除指定索引处的元素，返回被删除的元素
D:修改元素
public E set(int index,E element):修改指定索引处的元素，返回被修改的元素

  1. package com.igeek_05;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-11-25-15:12
  6.  */
  8. import java.util.ArrayList;
  10. /**
  11.  * ArrayList集合的删改查
  12.  * 1.获取元素：E get(int index)--返回指定索引处的元素
  13.  * 2.集合长度：int size()--返回一个集合中元素的个数
  14.  * 3.删除元素：boolean remove(Object obj)--删除指定的元素，返回的是一个Boolean值
  15.  *           E remove(int index)--删除指定索引处的元素，返回的是删除的元素
  16.  * 4.修改元素：E set(int index，E e)--修改指定索引处的元素，返回的是被修改的元素
  17.  */
  18. public class ArrayListDemo2 {
  19.     public static void main(String[] args) {
  20.         //创建集合对象
  21.         ArrayList<String> list=new ArrayList<String>();
  22.         //添加元素
  23.         list.add("刘德华");
  24.         list.add("郭富城");
  25.         list.add("黎明");
  26.         list.add("张学友");
  28.         //获取元素
  29.         System.out.println("get:"+list.get(0));//get:刘德华
  32.         //删除元素
  33. //        System.out.println("remove:"+list.remove(1));//remove:郭富城
  34. //        System.out.println("remove:"+list.remove("黎明"));//remove:true
  36.         //查看集合
  37.         System.out.println(list);
  39.         //修改元素
  40.         list.set(0,"刘芙蓉");
  41. //        System.out.println("set:"+list.set(0,"刘芙蓉"));
  42.         System.out.println(list);
  43.     }
  44. }

ArrayList遍历

集合的遍历思想和数组的遍历思想相同
循环遍历容器,依次取出里面的元素即可

  1. package com.igeek_05;
  3. import java.util.ArrayList;
  5. /**
  6.  * @author Lynn
  7.  * @create 2020-11-25-15:30
  8.  */
  10. /**
  11.  * ArrayList集合的遍历
  12.  * 与数组的遍历一样，长度改成size
  13.  */
  14. public class ArrayListDemo3 {
  15.     public static void main(String[] args) {
  16.         //创建集合对象
  17.         ArrayList<String> list=new ArrayList<String>();
  19.         list.add("Tom");
  20.         list.add("Lynn");
  21.         list.add("马宝国");
  23.         for (int i = 0; i <list.size() ; i++) {
  24.             //获取下标所对应的元素
  25.             System.out.println(list.get(i));
  26.         }
  27.     }
  29. }

ArrayList集合案例

ArrayList练习之存储字符串并遍历

向集合中添加任意四个字符串,遍历集合,依次打印取出的字符串

  1. package com.igeek_03;
  3. import java.util.ArrayList;
  5. /**  
  6.  * @ClassName: ArrayListTest  
  7.  * @Description: 存储字符串并遍历
  8.  * @date 2017年10月14日 上午10:09:10    
  9.  * Company www.igeekhome.com
  10.  *    
  11.  * 存储字符串并遍历
  12.  * 
  13.  * 分析：
  14.  *         A:创建集合对象
  15.  *         B:添加字符串元素
  16.  *         C:遍历集合
  17.  */
  18. public class ArrayListTest {
  19.     public static void main(String[] args) {
  20.         //创建集合对象
  21.         ArrayList<String> array = new ArrayList<String>();
  23.         //添加字符串元素
  24.         array.add("向问天");
  25.         array.add("刘正风");
  26.         array.add("左冷禅");
  27.         array.add("风清扬");
  29.         //遍历集合
  30.         for(int x=0; x<array.size(); x++) {
  31.             String s = array.get(x);
  32.             System.out.println(s);
  33.         }
  34.     }
  35. }

ArrayList练习之获取满足要求的元素

给定一个字符串数组：{“张三丰”,“宋远桥”,“张无忌”,“殷梨亭”,“张翠山”,“莫声谷”}，将数组中的元素添加到集合中，并把所有姓张的人员打印到控制台上

  1. package com.igeek_03;
  3. import java.util.ArrayList;
  5. /**  
  6.  * @ClassName: ArrayListTest2  
  7.  * @Description: ArrayList练习之获取满足要求的元素
  8.  * @date 2017年10月14日 上午10:11:10    
  9.  * Company www.igeekhome.com
  10.  *    
  11.  * 给定一个字符串数组：{“张三丰”,“宋远桥”,“张无忌”,“殷梨亭”,“张翠山”,“莫声谷”}，
  12.  * 将数组中的元素添加到集合中，并把所有姓张的人员打印到控制台上。
  13.  * 
  14.  * 分析：
  15.  *         A:定义字符串数组
  16.  *         B:创建集合对象
  17.  *         C:遍历字符串数组，获取到每一个字符串元素
  18.  *         D:把获取到的字符串元素添加到集合
  19.  *         E:遍历集合
  20.  *             要判断每一个字符串元素是否以"张"开头，如果是，就输出在控制台
  21.  */
  22. public class ArrayListTest2 {
  23.     public static void main(String[] args) {
  24.         //定义字符串数组
  25.         String[] strArray = {"张三丰","宋远桥","张无忌","殷梨亭","张翠山","莫声谷"};
  27.         //创建集合对象
  28.         ArrayList<String> array = new ArrayList<String>();
  30.         //遍历字符串数组，获取到每一个字符串元素
  31.         for(int x=0; x<strArray.length; x++) {
  32.             //把获取到的字符串元素添加到集合
  33.             array.add(strArray[x]);
  34.         }
  36.         //遍历集合
  37.         for(int x=0; x<array.size(); x++) {
  38.             String s = array.get(x);
  39.             //要判断每一个字符串元素是否以"张"开头，如果是，就输出在控制台
  40.             if(s.startsWith("张")) {
  41.                 System.out.println(s);
  42.             }
  43.         }
  44.     }
  45. }

ArrayList练习之存储自定义对象并遍历

A:自定义一个学生类,学生中有姓名和年龄属性,生成满参构造与空参构造
生成属性对应的getter/setter方法
B:在测试类中使用满参构造创建三个学生对象,然后将每个学生对象均添加到ArrayList集合中
C:遍历这个ArrayList集合,依次打印出每个学生的姓名和年龄

  1. package com.igeek_06;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-11-25-14:21
  6.  */
  8. import sun.management.counter.perf.PerfInstrumentation;
  10. /**
  11.  * 当前这个学生类是一个实体类
  12.  */
  13. public class Student {
  14.     //属性
  15.     private String name;
  16.     private String age;
  18.     //构造函数
  19.     public Student() {
  20.     }
  22.     public Student(String name, String age) {
  23.         this.name = name;
  24.         this.age = age;
  25.     }
  27.     public String getName() {
  28.         return name;
  29.     }
  31.     public void setName(String name) {
  32.         this.name = name;
  33.     }
  35.     public String getAge() {
  36.         return age;
  37.     }
  39.     public void setAge(String age) {
  40.         this.age = age;
  41.     }
  43.     @Override
  44.     public String toString() {
  45.         return "Student{" +
  46.                 "name='" + name + '\'' +
  47.                 ", age=" + age +
  48.                 '}';
  49.     }
  50. }
  1. package com.igeek_06;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-11-25-15:35
  6.  */
  8. import java.util.ArrayList;
  9. import java.util.Scanner;
  11. /**
  12.  * 键盘录入数据并且存储和遍历
  13.  *
  14.  * 创建一个学生类的集合，遍历学生集合
  15.  *
  16.  * 分析：
  17.  * 1.定义学生类
  18.  * 2.创建集合对象
  19.  * 3.键盘录入数据，创建学生对象，把键盘录入的数据赋值给学生对象的成员变量
  20.  * 4.把学生对象存放在集合中
  21.  * 5.遍历集合
  22.  */
  23. public class StudentDemo {
  24.     public static void main(String[] args) {
  25.         //2.创建集合对象--泛型是学生类型
  26.         ArrayList<Student> array=new ArrayList<Student>();
  28.         //调用方法
  29.         addStudent(array);
  30.         addStudent(array);
  31.         addStudent(array);
  33.         //遍历集合
  34.         for (int i = 0; i < array.size() ; i++) {
  35.             Student s=array.get(i);
  36.             System.out.println(s.getName()+" "+s.getAge());
  37.         }
  38.     }
  39.     //定义一个方法用于封装添加学生
  40.     //建议修饰符使用private，因为这个方法是只在当前这个类中使用，为了封装的彻底性
  41.     public static void addStudent(ArrayList<Student> array){
  42.         //键盘录入数据，创建成对象，把键盘录入的数据赋值给学生对象的成员变量
  43.         Scanner sc=new Scanner(System.in);
  44.         System.out.println("请输入学生的姓名：");
  45.         String name=sc.nextLine();
  46.         System.out.println("请输入学生的年龄：");
  47.         String age=sc.nextLine();
  49.         //创建学生对象
  50.         Student s=new Student();
  51.         //属性赋值
  52.         s.setName(name);//name是获取到的用户输入的名字
  53.         s.setAge(age);
  55.         //把学生对象放进集合中保存
  56.         array.add(s);
  58. //        sc.close();
  59.     }
  60. }

练习

  1. package practice;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-11-25-16:12
  6.  */
  8. /**
  9.  * 实现1注册，2登录，3退出
  10.  */
  11. public class User {
  12.     //定义成员变量
  13.     private String name;
  14.     private String birth;
  15.     private String hobby;
  16.     private String password;
  19.     //构造方法
  20.     public User() {
  21.     }
  23.     public User(String name, String birth, String hobby, String password) {
  24.         this.name = name;
  25.         this.birth = birth;
  26.         this.hobby = hobby;
  27.         this.password = password;
  28.     }
  30.     //get/set
  32.     public String getName() {
  33.         return name;
  34.     }
  36.     public void setName(String name) {
  37.         this.name = name;
  38.     }
  40.     public String getBirth() {
  41.         return birth;
  42.     }
  44.     public void setBirth(String birth) {
  45.         this.birth = birth;
  46.     }
  48.     public String getHobby() {
  49.         return hobby;
  50.     }
  52.     public void setHobby(String hobby) {
  53.         this.hobby = hobby;
  54.     }
  56.     public String getPassword() {
  57.         return password;
  58.     }
  60.     public void setPassword(String password) {
  61.         this.password = password;
  62.     }
  64.     @Override
  65.     public String toString() {
  66.         return "User{" +
  67.                 "name='" + name + '\'' +
  68.                 ", birth='" + birth + '\'' +
  69.                 ", hobby='" + hobby + '\'' +
  70.                 ", password='" + password + '\'' +
  71.                 '}';
  72.     }
  73. }
  1. package practice;
  3. import java.util.ArrayList;
  4. import java.util.Scanner;
  6. /**
  7.  * @author Lynn
  8.  * @create 2020-11-25-16:12
  9.  */
  10. public class Test {
  11.     public static void main(String[] args) {
  12.         //创建集合对象存放User数据
  13.         ArrayList<User> list=new ArrayList<User>();
  14.         Scanner sc=new Scanner(System.in);
  15.         while(true){
  16.             System.out.println("1注册，2登录，3退出");
  17.             int num=sc.nextInt();
  19.             if(num==1){
  20.                 register(list);
  21.             }
  22.             else if(num==2){
  23.                 login(list);
  24.             }
  25.             else if(num==3){
  26.                 System.out.println("谢谢使用！");
  27.                 System.exit(0);
  29.             }
  30.             else {
  31.                 System.out.println("输入方式有误！");
  32.             }
  34.         }
  36.     }
  37.     //定义register方法
  38.     public static void register(ArrayList<User> list){
  39.         Scanner sc=new Scanner(System.in);
  40.         System.out.println("请输入你的用户名：");
  41.         String name=sc.nextLine();
  42.         System.out.println("请输入登录密码:");
  43.         String password=sc.nextLine();
  44.         System.out.println("请输入你的出生日期:");
  45.         String birth=sc.nextLine();
  46.         System.out.println("请输入你的爱好;");
  47.         String hobby=sc.nextLine();
  48.         //创建用户对象
  49.         User u=new User();
  50.         //属性赋值
  51.         u.setName(name);
  52.         u.setPassword(password);
  53.         u.setBirth(birth);
  54.         u.setHobby(hobby);
  55.         //将用户对象保存在集合中
  56.         list.add(u);
  57.         System.out.println("注册成功！");
  58.     }
  59.     //定义login方法
  60.     public static void login(ArrayList<User> list){
  61.         Scanner sc=new Scanner(System.in);
  62.         System.out.println("请输入你的用户名：");
  63.         String name=sc.nextLine();
  64.         System.out.println("请输入登录密码:");
  65.         String password=sc.nextLine();
  67.         User u=new User();
  69.         u.setName(name);
  70.         u.setPassword(password);
  71.         //进行判断
  72.         boolean flag=false;
  73.         for (int i = 0; i < list.size() ; i++) {
  74.             if(list.get(i).getName().equals(u.getName()) && list.get(i).getPassword().equals(u.getPassword())){
  75.                 System.out.println("以下是你的个人信息"+list.get(i));
  76.                 flag=true;
  77.             }
  78.         }
  79.         if(!flag){
  80.             System.out.println("你的用户名或者密码输入错误！");
  81.         }
  82.     }
  83. }

学生管理系统案例实现

  1. package practice03;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-11-26-9:31
  6.  */
  8. /**
  9.  * 这是一个学生的实体类
  10.  */
  11. public class Student {
  12.     //属性--为了方便获取字符串的信息，统一设置为字符串类型
  13.     private String id;
  14.     private String name;
  15.     private String age;
  16.     private String address;
  18.     public Student() {
  20.     }
  22.     public Student(String id, String name, String age, String address) {
  23.         this.id = id;
  24.         this.name = name;
  25.         this.age = age;
  26.         this.address = address;
  27.     }
  29.     public String getId() {
  30.         return id;
  31.     }
  33.     public void setId(String id) {
  34.         this.id = id;
  35.     }
  37.     public String getName() {
  38.         return name;
  39.     }
  41.     public void setName(String name) {
  42.         this.name = name;
  43.     }
  45.     public String getAge() {
  46.         return age;
  47.     }
  49.     public void setAge(String age) {
  50.         this.age = age;
  51.     }
  53.     public String getAddress() {
  54.         return address;
  55.     }
  57.     public void setAddress(String address) {
  58.         this.address = address;
  59.     }
  60. }
  1. package practice03;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-11-26-9:28
  6.  */
  8. import java.util.ArrayList;
  9. import java.util.Scanner;
  11. /**
  12.  * 这是一个学生管理系统
  13.  * 步骤：
  14.  * 1.定义一个学生类
  15.  * 2.学生管理系统主界面的编写
  16.  * 3.学生管理系统的查看所有学生的信息
  17.  * 4.添加学生信息
  18.  * 5.删除学生信息
  19.  * 6.修改学生信息
  20.  */
  21. public class StudentMangerTest {
  22.     public static void main(String[] args) {
  23.         //定义一个学生类型集合
  24.         ArrayList<Student> array=new ArrayList<Student>();
  25.         //为了用户体验度，设计一个界面
  26.         //利用循环的方式可以重复的展示界面，直到退出程序纠结束循环
  27.         while(true){
  28.             //主界面的欢迎词
  29.             System.out.println("---------------------欢迎来到学生管理系统------------------------");
  30.             System.out.print("1 查看所有学生"+"\t");
  31.             System.out.print("2 添加学生"+"\t");
  32.             System.out.print("3 删除学生"+"\t");
  33.             System.out.print("4 修改学生"+"\t");
  34.             System.out.print("5 退出系统"+"\t");
  35.             System.out.println();
  36.             //键盘录入获取
  37.             Scanner sc=new Scanner(System.in);
  38.             String choiceString=sc.nextLine();
  40.             //用开关键--switch···case
  41.             switch (choiceString){
  42.                 case "1":
  43.                     //查看所有学生
  44.                     findAllAtudent(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.                 default:
  61.                     System.out.println("谢谢使用，欢迎下次再来！");
  62.                     System.exit(0);//Java中提供的
  63.                     break;
  65.             }
  66.         }
  67.     }
  68.     //封装一个方法用于查询学生的所有信息
  69.     public static void findAllAtudent(ArrayList<Student> array){
  70.         //首先来判断集合中是否有数据，如果没有数据，就给出提示，并让该方法不继续往下执行
  71.         if(array.size()==0){
  72.             System.out.println("抱歉！目前没有学生信息可供查询,请回去重新选择你的操作");
  73.             return;//将当前的方法直接结束
  74.         }
  75.         //有学生的情况下--遍历查询
  76.         //\t表示一个Tab键--制表符
  77.         System.out.println("学号\t姓名\t年龄\t居住地");
  78.         for (int i = 0; i < array.size() ; i++) {
  79.             Student s= array.get(i);
  80.             //输出属性
  81.             System.out.println(s.getId()+"\t"+
  82.                     s.getName()+"\t"+
  83.                     s.getAge()+"\t"+
  84.                     s.getAddress());
  85.         }
  86.     }
  88.     //封装一个方法用于添加学生信息
  89.     public static void addStudent(ArrayList<Student> array){
  90.         //键盘录入对象
  91.         Scanner sc=new Scanner(System.in);
  92.         //所有的对学生的操作都是基于id，所以我们把id属性放到循环的外面
  93.         String id;
  94.         //能够实现重复添加学生的信息，所以使用循环
  95.         while (true){
  96.             //判断一下这个学号是不是已经存在
  97.             System.out.println("请输入学号：");
  98.             id=sc.nextLine();
  99.             //定义一个标记--假设不存在
  100.             boolean flag=false;
  101.             //遍历学号--就是遍历数组
  102.             for (int i = 0; i < array.size() ; i++) {
  103.                 Student s= array.get(i);
  104.                 //获取学号
  105.                 if(s.getId().equals(id)){
  106.                     flag=true;//学号存在
  107.                     break;
  108.                 }
  109.             }
  110.             //这个时候flag就是true
  111.             if(flag){
  112.                 System.out.println("你的学号已经被占用，请重新输入！");
  113.             }else {
  114.                 break;
  115.             }
  116.         }
  118.         //通过验证可以添加学生
  119.         System.out.println("请输入学生姓名：");
  120.         String name=sc.nextLine();
  122.         System.out.println("请输入学生年龄：");
  123.         String age=sc.nextLine();
  125.         System.out.println("请输入学生住址：");
  126.         String address=sc.nextLine();
  128.         //创建学生对象
  129.         Student s=new Student();
  130.         //赋值
  131.         s.setId(id);
  132.         s.setName(name);
  133.         s.setAge(age);
  134.         s.setAddress(address);
  136.         //把学生保存到集合中
  137.         array.add(s);
  139.         //给出提示
  140.         System.out.println("添加学生成功！");
  141.     }
  143.     //封装一个方法用于删除学生信息
  144.     public static void deleteStudent(ArrayList<Student> array) {
  145.         //删除学生的思路：键盘录入一个学号，到集合中去查找，看是否有学生使用的是该学号，如果有就删除该学生
  146.         //创建键盘录入对象
  147.         Scanner sc=new Scanner(System.in);
  148.         System.out.println("请输入你要删除的学生的学号：");
  149.         String id=sc.nextLine();
  151.         //遍历集合看看这个id所对应的学生是不是存在--设置一个索引
  152.         int index=-1;
  153.         for (int i = 0; i < array.size() ; i++) {
  154.             //获取每一个学生
  155.             Student s= array.get(i);
  156.             //判断学生的学号和键盘录入的id进行比较
  157.             if(s.getId().equals(id)){//要删除的对象存在
  158.                 index=i;
  159.                 break;
  160.             }
  161.         }
  162.         if(index==-1){
  163.             System.out.println("抱歉！你要删除的学号对应的学生信息不存在,请回去重新你的选择");
  164.         }else {
  165.             array.remove(index);
  166.             System.out.println("删除成功！");
  167.         }
  168.     }
  170.     //封装一个方法用于修改学生信息
  171.     public static void updateStudent(ArrayList<Student> array){
  172.         //修改学生的思路：键盘录入一个学号，到集合中去查找，看是否有学生使用的是该学号，如果有就修改该学生
  173.         //创建键盘录入对象
  174.         Scanner sc=new Scanner(System.in);
  175.         System.out.println("请输入你要修改的学生的学号：");
  176.         String id=sc.nextLine();
  178.         //遍历集合看看这个id所对应的学生是不是存在--设置一个索引
  179.         int index=-1;
  180.         for (int i = 0; i < array.size() ; i++) {
  181.             //获取每一个学生
  182.             Student s= array.get(i);
  183.             //判断学生的学号和键盘录入的id进行比较
  184.             if(s.getId().equals(id)){//要修改的对象存在
  185.                 index=i;
  186.                 break;
  187.             }
  188.         }
  189.         if(index==-1){
  190.             System.out.println("抱歉！你要修改的学号对应的学生信息不存在,请回去重新你的选择");
  191.         }else {
  192.             //开始进行修改
  193.             System.out.println("请输入新的学生姓名：");
  194.             String name=sc.nextLine();
  195.             System.out.println("请输入新的学生年龄：");
  196.             String age=sc.nextLine();
  197.             System.out.println("请输入新的学生住址：");
  198.             String address=sc.nextLine();
  200.             //创建一个新的对象
  201.             Student s=new Student();
  202.             s.setId(id);
  203.             s.setName(name);
  204.             s.setAge(age);
  205.             s.setAddress(address);
  207.             //修改集合中的学生对象--实际上就是把原来的信息替换
  208.             array.set(index,s);
  210.             System.out.println("修改成功！");
  211.         }
  212.     }
  213. }