JavaSE 基础 (8) 学生管理系统

集合和数组的区别对比

对象数组

需求：将 (张三，23) (李四，24) (王五，25) 封装为3个学生对象并存入数组, 随后遍历数组，将学生信息输出在控制台

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


public static void main(String[] args){
	//2.动态初始化长度为3的数组，类型为Student类型
	Student[] arr = new Student[3];
	
  //3.根据需求创建3个学生对象
	Student stu1 = new Student("张三"，23);
	Student stu2 = new Student("李四"，24);
	Student stu3 = new Student("王五"，25);
	
  //4.将学生对象存入数组
	arr[0] = stu1;
	arr[1] = stu2;
	arr[2] = stu3;
	
  //5.遍历数组，取出每一个学生对额
	for(int i=0;i<arr.length;i++){
		Student temp arr[i];
		System.out.println(temp.getName() + "..." + temp.getAge());
	}
}

但是数组存在一个问题, 再添加一个数据的时候, 需要再创建一个新的数组, 把老的数组中的元素复制到新的数组中, 因为数组的长度是固定不变的

集合和数组的特点对比

集合类的特点：提供一种存储空间可变的存储模型，存储的数据容量可以发生改变
集合和数组的区别：
共同点：都是存储数据的容器
不同点：数组的容量是固定的，集合的容量是可变的

如果存储的数据, 长度经常发生改变, 推荐使用集合

ArrayList的构造方法和添加方法

ArrayList 集合

集合类有很多，目前我们先学习一个：ArrayList

ArrayList 底层是数组, 通过使用 arraycopy 方法, 来实现动态扩容, 例如, 当 ArrayList 数组里没有元素时, 空间为 0, 当存放元素时, 才会分配空间, 当 10 个空间满时, 再创建一个为 15 的新的空间, 将空间为 10 的数组里的元素通过 arraycopy 转移到空间 15 的数组, 每次创建新的数组的空间大小为老的数组空间 + 老的数组空间的一半(取整数)

集合的底层使用的是数组

构造方法

方法名	说明
public ArrayList( )	创建一个空的集合对象
public boolean add(E e)	将指定的元素追加到此集合的末尾
public void add(int index,E element)	在此集合中的指定位置插入指定的元素

ArrayList 创建的容器会自动扩容, 所以只需创建一个集合容器对象即可

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


public static void main(String[] args){
	//1.创建集合容器对象
	ArrayList list = new ArrayList();
	
  //2.调用对象的add方法，向容器中添加数据
	list.add("abc");
	list.add(123);
	list.add(true);
	System.out.println(list); //[abc, 123, true]
}

打印 String、StringBuilder、集合名 都不会出现内存地址

集合容器如果没有添加 <>, 就可以存储任意数据类型

1

ArrayList<String> list = new ArrayList<String>();

加上 <> 即可对集合容器里存储的数据类型进行限制, 泛型 <>, <> 里只能写引用数据类型

前面加个 <>, 后面也要加个 <>

JDK 7 之后, 后面 <> 中的内容可以不写, 它会自动匹配到前面的类型

1

ArrayList<String> list = new ArrayList< >();

add(int index,E element)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


public static void main(String[] args){
	//1.创建集合容器对象
	ArrayList<String>list = new ArrayList<>();
	
  //2.调用对象的add方法，向容器中添加数据
	list.add("111");
	list.add("222");
	list.add("333");
	list.add("444");
	list.add("555");
	
	list.add(0, "666");
	System.out.println(list); //[666,111,222,333,444,555]
}

ArrayList常用成员方法

方法名	说明
public boolean remove(Object o)	删除指定的元素，返回删除是否成功
public E remove(int index)	删除指定索引处的元素，返回被删除的元素
public E set(int index,E element)	修改指定索引处的元素，返回被修改的元素
public E get(int index)	返回指定索引处的元素
public int size( )	返回集合中的元素的个数

方法的返回值我们一般都不接收, 只是调用而已

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60


public static void main(String[] args){
	ArrayList<String> list = new ArrayList<>();
	list.add("abc");
	list.add("111");
	list.add("222");
	list.add("333");
	list.add("444");
	list.add("555");
	
	//public E get(int index),返回指定索引处的元素
	String s1 = list.get(0);
	String s2 = list.get(1);
	String s3 = list.get(2);
	
	System.out.println(s1); //abc
	System.out.println(s2); //111
	System.out.println(s3); //222
}

//测试修改
public static void testSet(){
	ArrayList<String> list = new ArrayList<>();
	list.add("abc");
	list.add("111");
	list.add("222");
	list.add("333");
	list.add("444");
	list.add("555");
	
	//public E set(int index,E element)  修改指定索引处的元素，返回被修改的元素
	String s list.set(0,"666");
	System.out.println(s);  //abc
	
	System.out.println(list);  //[666,111,222,333,444,555]
}

//测试删除
public static void testRemove(){
	ArrayList<String> list = new ArrayList<>();
	list.add("abc");
	list.add("111");
	list.add("222");
	list.add("333");
	list.add("444");
	list.add("555");
	
	//public boolean remove(Object o) 删除指定的元素，返回删别除是否成功
	boolean b1 = list.remove("abc");
	boolean b2 = list.remove("zzz");
	
	System.out.println(b1);  //true
	System.out.println(b2);  //false
	System.out.println(list);  //[111,222,333,444,555]
	
	//public E remove(int index)  删除指定索引处的元素，返回被删除的元素
	String s = list.remove(0);
	System.out.println(s);
	
	System.out.println(list);
}

集合存储字符串并遍历

/images/java/JavaSE 基础 (8) 学生管理系统/1.png — (`图1`)

需求：创建一个存储字符串的集合，存储 3 个字符串元素，使用程序实现在控制台遍历该集合

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


public static void main(String[] args){
	//1.创建集合对象
	ArrayList<String>list = new ArrayList<>();
	//2.往集合中添加字符串对象
	list.add("张三");
	list.add("李四");
	list.add("王五");
	//3.遍历集合
	for(int i=0;i<list.size();i++){
		//i：每一个索引值
		String s = list.get(i);
		System.println(s);
	}
}

集合存储学生对象并遍历

需求：创建一个存储学生对象的集合，存储 3 个学生对象，使用程序实现在控制台遍历该集合

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


public static void main(String[] args){
	//2.创建集合对象
	ArrayList<Student> list = new ArrayList<>();
	//3.创建学生对象
	Student stu1 = new Student("张三1"，age:23);
	Student stu2 = new Student("张三2"，age:23);
	Student stu3 = new Student("张三3"，age:23);
	//4.添加学生对象到集合中
	list.add(stu1);
	list.add(stu2);
	list.add(stu3);
	//5.遍历集合，采用通用遍历格式实现
	for (int i=0; i < list.size(); i++){
		Student stu = list.get(i);
		System.out.println(stu.getName() + "..." + stu.getAge());
	}
}

键盘录入学生信息到集合

需求：创建一个存储学生对象的集合，存储 3 个学生对象，使用程序实现在控制台遍历该集合

学生的姓名和年龄来自于键盘录入

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


public static void main(String[] args){
	//2.创建集合对象
	ArrayList<Student> list = new ArrayList<>();
	Student stu1 = getstudent();
	Student stu2 = getstudent();
	Student stu3 = getStudent();
	//5.在集合中添加学生对象
	list.add(stu1);
	list.add(stu2);
	list.add(stu3);
	//6.遍历集合，采用通用遍历格式实现
	for(int i=0; i < list.size(); i++){
		Student stu = list.get(i);
		System.out.println(stu.getName（）+ "..." + stu.getAge());
	}
}


public static Student getStudent(){
	//3.键盘录入学生对象所需要的数据
	Scanner sc = new Scanner(System.in);
	System.out.println("请输入学生姓名：");
	//next()  nextInt()
	String name = sc.next();
	System.out.printIn("请输入学生年龄：");
	int age = sc.nextInt();
	//4.创建学生对象，把键盘录入的数据赋值给学生对象的成员变量
	Student stu =new Student(name,age);
	
	return stu;
}

集合删除元素

需求：创建一个存储 String 的集合，内部存储（test，张三，李四，test，test）字符串

删除所有的 test 字符串，删除后，将集合剩余元素打印在控制台

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


public static void main(String[] args){
	//1．创建集合对象
	ArrayList<String> list = new ArrayList<>();
	//2．调用add方法，添加字符串
	list.add("test");
	list.add("张三");
	list.add("李四");
	list.add("test");
	list.add("test");
	
	list.remove("test");
	System.out.println(list);  //[张三，李四，test,test]
}

remove(Object o) 根据元素删除的方式，只能删除集合中第一次遇到的，后面如果有重复的元素，则无法删除

使用 “test”.equals(s)，这样就不会出现空指针异常，尽量使用常量进行比较，可以减少一些不必要的空指针异常

此时仍剩余一个没有删除

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


public static void main(String[] args){
	//1.创建集合对象
	ArrayList<String> list = new ArrayList<>();
	//2.调用add方法，添加字符串
	list.add("test");
	list.add("张三");
	list.add("李四");
	list.add("test");
	list.add("test");
	//3.遍历集合，取出每一个字符串元素
	for(int i = 0；i < list.size(); i++){
		String s = list.get(i);
		//4.加入f判断，如果是test字符串，调用remove方法删除
		//if(s.equals("test")){}
		if("test".equals(s)){
			list.remove(i);
		}
	}
	System.out.println(list);  //[张三，李四，test]
}

添加 i-- 才能全部删除

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


public static void main(String[] args){
	//1.创建集合对象
	ArrayList<String> list = new ArrayList<>();
	//2.调用add方法，添加字符串
	list.add("test");
	list.add("张三");
	list.add("李四");
	list.add("test");
	list.add("test");
	//3.遍历集合，取出每一个字符串元素
	for(int i = 0；i < list.size(); i++){
		String s = list.get(i);
		//4.加入f判断，如果是test字符串，调用remove方法删除
		//if(s.equals("test")){}
		if("test".equals(s)){
			list.remove(i);
			i--;
		}
	}
	System.out.println(list);  //[张三，李四]
}

原因如下

/images/java/JavaSE 基础 (8) 学生管理系统/2.png — (`图2`)

/images/java/JavaSE 基础 (8) 学生管理系统/3.png — (`图3`)

0 号索引位置的元素删除后，里边是空的，不能空着，后边的元素统一向前移动

集合数据筛选

需求：定义一个方法，方法接收一个集合对像(泛型为 Student), 方法内部将年龄低于 18 的学生对象找出并存入新集合对象，方法返回新集合。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


public static void main(String[] args){
	//7.main方法中测试该方法
	ArrayList<Student> list = new ArrayList<>();
	Student stu1 = new Student("张三1"，10);
	Student stu2 = new Student("张三2"，10);
	Student stu3 = new Student("张三3"，20);
	list.add(stu1);
	list.add(stu2);
	list.add(stu3);
	ArrayList<Student> newList = getlist(list);
	for(int i = 0; i < newList.size(); i++){
		Student stu = newList.get(i);
		System.out.println(stu.getName()+ "..." + stu.getAge());
	}
}

public static ArrayList<Student> getList(ArrayList<Student> list){
	//2.方法内部定义新集合，准备存储筛选出的学生对象ArrayList<Student> newList
	ArrayList<Student> newList = new ArrayList<>();
	//3.遍历原集合，获取每一个学生对象
	for(int i = 0; i < list.size(); i++){
		Student stu = list.get(i);
		//4.通过学生对象调用getAge方法获取年龄，并判断年龄是否低于18
		int age = stu.getAge();
		if(age < 18){
			//5.将年龄低于18的学生对象存入新集合
			newList.add(stu);
		}
	}
	//6.返回新集合
	return newList;
}

学生管理系统项目演示

/images/java/JavaSE 基础 (8) 学生管理系统/4.png — (`图4`)

实现步骤分析和学生类的代码编写

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48


public class Student{
	private String sid;  //学号
	private String name; //姓名
	private int age; //年龄
	private String birthday;  //生日

	public Student(){
	}

	public Student(String sid,String name,int age,String birthday){
		this.sid = sid;
		this.name = name;
		this.age = age;
		this.birthday = birthday;
	}
	
	public String getSid(){
		return sid;
	}

	public void setSid(String sid){
		this.sid = sid;
	}
	
	public String getName(){
		return name;
	}
	
	public void setName(String name){
		this.name = name;
	}
	
	public int getAge(){
		return age;
	}

	public void setAge(int age){
		this.age = age;
	}
	
	public int getBirthday(){
		return birthday;
	}

	public void setBirthday(int birthday){
		this.birthday = birthday;
	}
}

菜单搭建

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40


public static void main(String[] args){
	Scanner sc = new Scanner(System.in);
	
	lo:
	while(true){
		//1.搭建主界面菜单
		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.printIn("请输入您的选择：");

		String choice = sc.next();
	
		switch(choice){
			case "1":
				System.out.println("添加学生");
				break;
			case "2":
				System.out.println("删除学生");
				break;
			case "3":
				System.out.println("修改学生");
				break;
			case "4":
				System.out.println("查看学生");
				break;
			case "5":
				System.out.println("感谢您的使用");
				break lo;
			default:
				System.out.println("您的输入有误");
				break;
		}
	}	

	
}

添加学生逻辑-基本实现

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65


public static void main(String[] args){
	Scanner sc = new Scanner(System.in);
	
	//创建集合容器对象
	ArrayList<Student> list = new ArrayList<>();
	
	lo:
	while(true){
		//1.搭建主界面菜单
		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.printIn("请输入您的选择：");

		String choice = sc.next();
	
		switch(choice){
			case "1":
				//System.out.println("添加学生");
				addStudent(list);
				break;
			case "2":
				System.out.println("删除学生");
				break;
			case "3":
				System.out.println("修改学生");
				break;
			case "4":
				System.out.println("查看学生");
				break;
			case "5":
				System.out.println("感谢您的使用");
				break lo;
			default:
				System.out.println("您的输入有误");
				break;
		}
	}
	

	
}

//添加学生的方法
public static void addstudent(ArrayList<Student> list){
	Scanner sc = new Scanner(System.in);
	//1.给出录入的提示信息
	System.out.println("请输入学号：");
	String sid = sc.next();
	System.out.println("请输入姓名：");
	String name = sc.next();
	System.out.println("请输入年龄：");
	int age = sc.nextInt();
	System.out.println("请输入生日：");
	String birthday = sc.next();
	//2.将键盘录入的信息封装为学生对象
	Student stu  =new Student(sid,name,age,birthday);
	//3.将封装好的学生对象，添加到集合容器当中
	list.add(stu);
	//4.给出添加成功的提示信息
	System.out.println("添加成功！")；
}

查看学生代码实现

思路
① 用键盘录入选择查看所有学生信息
② 定义一个方法，用于查看学生信息

判定集合中是否有数据，如果没有显示提示信息
显示表头信息
将集合中数据取出按照对应格式显示学生信息，年龄显示补充"岁"

③ 调用方法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59


public static void main(String[] args){
	Scanner sc = new Scanner(System.in);
	
	//创建集合容器对象
	ArrayList<Student> list = new ArrayList<>();
	
	lo:
	while(true){
		//1.搭建主界面菜单
		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.printIn("请输入您的选择：");

		String choice = sc.next();
	
		switch(choice){
			case "1":
				//System.out.println("添加学生");
				addStudent(list);
				break;
			case "2":
				System.out.println("删除学生");
				break;
			case "3":
				System.out.println("修改学生");
				break;
			case "4":
				//System.out.println("查看学生");
				queryStudents(list);
				break;
			case "5":
				System.out.println("感谢您的使用");
				break lo;
			default:
				System.out.println("您的输入有误");
				break;
		}
	}
}

//查看所有学生
public static void queryStudents(ArrayList<Student> list){
	//1.判断集合中是否存在数据，如果不存在直接给出提示
	if(list.size（）== 0){
		System.out.printIn("无信息，请添加后重新查询");
		return;
	}
	//2.存在：展示表头数据
	System.out.printIn("学号\t姓名\t年龄\t生日");
	//3.遍历集合，获取每一个学生对象的信息，打印在控制台
	for (int i=0;i<list.size（）;i++){
		Student stu = list.get(i);
		System.out.printin(stu.getsi() + "\t" + stu.getName() + "\t" + stu.getAge() + "\t" + stu.getBirthday();
	}
}

判断学号是否存在的方法定义

删除/修改学生学号不存在问题

① 在删除/修改学生操作前，对学号是否存在进行判断

如果不存在，显示提示信息
如果存在，执行删除/修改操作

思路：定义一个方法，该方法用于从集合中，查找【学号】在【集合】中出现的索引位置

学号存在：返回正确的索引位置
学号不存在：返回-1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


public static int getIndex(ArrayList<Student> list,String sid){
	//1.假设传入的学号，在集合中不存在
	int index =-1;
	//2.遍历集合，获取每一个学生对象，准备进行查找
	for (int i = 0; i < list.size(); i++){
		Student stu = list.get(i);
		//3.获取每一个学生对象的学号
		String id = stu.getsid();
		//4.使用获取出的学生学号，和传入的学号（查找的学号）进行比对
		if(id.equals(sid)){
			//存在：让index变量记录正确的索引位置
			index = i;
		}
	}
	return index;
}

册除学生代码实现

删除学生的代码编写

思路
① 用键盘录入选择删除学生信息
② 定义一个方法，用于删除学生信息

显示提示信息
键盘录入要删除的学生学号
调用 getIndex 方法，查找该学号在集合的索引
如果索引为 -1，提示信息不存在
如果索引不是 -1，调用 remove 方法删除，并提示删除成功

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81


public static void main(String[] args){
	Scanner sc = new Scanner(System.in);
	
	//创建集合容器对象
	ArrayList<Student> list = new ArrayList<>();
	
	lo:
	while(true){
		//1.搭建主界面菜单
		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.printIn("请输入您的选择：");

		String choice = sc.next();
	
		switch(choice){
			case "1":
				//System.out.println("添加学生");
				addStudent(list);
				break;
			case "2":
				//System.out.println("删除学生");
				deleteStudent(list);
				break;
			case "3":
				System.out.println("修改学生");
				break;
			case "4":
				//System.out.println("查看学生");
				queryStudents(list);
				break;
			case "5":
				System.out.println("感谢您的使用");
				break lo;
			default:
				System.out.println("您的输入有误");
				break;
		}
	}
}

//删除学生信息
public static void deleteStudent(ArrayList<Student> list){
	//1.给出提示信息（请输入您要删除的学号）
	System.out.println("请输入您要删除的学生学号：");
	//2.键盘接收要删除的学号
	Scanner sc = new Scanner(System.in);
	String deleteSid = sc.next();
	//3.调用getIndex方法，查找该学号在集合中出现的索引位置
	int index = getIndex(list,deletesid);
	//4.根据索引判断，学号在集合中是否存在
	if(index == -1){
		//不存在：给出提示
		System.out.print1ln("查无信息，请重新输入");
	}else{
		//存在：删除
		list.remove(index);
		System.out.println("删除成功")；
	}
}

public static int getIndex(ArrayList<Student> list,String sid){
	//1.假设传入的学号，在集合中不存在
	int index =-1;
	//2.遍历集合，获取每一个学生对象，准备进行查找
	for (int i = 0; i < list.size(); i++){
		Student stu = list.get(i);
		//3.获取每一个学生对象的学号
		String id = stu.getsid();
		//4.使用获取出的学生学号，和传入的学号（查找的学号）进行比对
		if(id.equals(sid)){
			//存在：让index变量记录正确的索引位置
			index = i;
		}
	}
	return index;
}

修改学生代码实现

思路
① 用键盘录入选择修改学生信息
② 定义一个方法，用于修改学生信息

显示提示信息
键盘录入要修改的学生学号
调用 getIndex 方法，查找该学号在集合的索引
如果索引为 -1，提示信息不存在
如果索引不是 -1，键盘录入要修改的学生信息
集合修改对应的学生信息
给出修改成功提示

③ 调用方法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89


public static void main(String[] args){
	Scanner sc = new Scanner(System.in);
	
	//创建集合容器对象
	ArrayList<Student> list = new ArrayList<>();
	
	lo:
	while(true){
		//1.搭建主界面菜单
		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.printIn("请输入您的选择：");

		String choice = sc.next();
	
		switch(choice){
			case "1":
				//System.out.println("添加学生");
				addStudent(list);
				break;
			case "2":
				//System.out.println("删除学生");
				deleteStudent(list);
				break;
			case "3":
				//System.out.println("修改学生");
				updateStudent(list);
				break;
			case "4":
				//System.out.println("查看学生");
				queryStudents(list);
				break;
			case "5":
				System.out.println("感谢您的使用");
				break lo;
			default:
				System.out.println("您的输入有误");
				break;
		}
	}
}

public static void updateStudent(ArrayList<Student> list){
	System.out.println("请输入您要修改的学生学号：");
	//2.键盘接收要修改的学号
	Scanner sc = new Scanner(System.in);
	String updateSid = sc.next();
	//3.调用getIndex方法，查找该学号在集合中出现的索引位置
	int index = getIndex(list,updateSid);
	//4.根据索引判断，学号在集合中是否存在
	if(index == -1){
		//不存在：给出提示
		System.out.print1ln("查无信息，请重新输入");
	}else{
		//存在：接收新的学生信息
		System.out.println("请输入新的学生姓名：");
		String name = sc.next();
		System.out.println("请输入新的学生年龄：");
		int age = sc.nextInt();
		System.out.printIn("请输入新的学生生日：");
		String birthday = sc.next();
		//封装为新的学生对象
		Student stu = new Student(updateSid,name,age,birthday);
		//调用集合的set方法，完成修改
		list.set(index,stu);
		System.out.println("修改成功");
	}
}

public static int getIndex(ArrayList<Student> list,String sid){
	//1.假设传入的学号，在集合中不存在
	int index =-1;
	//2.遍历集合，获取每一个学生对象，准备进行查找
	for (int i = 0; i < list.size(); i++){
		Student stu = list.get(i);
		//3.获取每一个学生对象的学号
		String id = stu.getsid();
		//4.使用获取出的学生学号，和传入的学号（查找的学号）进行比对
		if(id.equals(sid)){
			//存在：让index变量记录正确的索引位置
			index = i;
		}
	}
	return index;
}

解决添加学生学号的重复问题

思路
① 在添加学生录入学号后，调用 getlndex 方法
② 根据方法的返回值，判断学号是否存在

返回值为-1：不存在，可以存储
返回值为正确索引：存在，给出提示，重新接收信息

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93


public static void main(String[] args){
	Scanner sc = new Scanner(System.in);
	
	//创建集合容器对象
	ArrayList<Student> list = new ArrayList<>();
	
	lo:
	while(true){
		//1.搭建主界面菜单
		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.printIn("请输入您的选择：");

		String choice = sc.next();
	
		switch(choice){
			case "1":
				//System.out.println("添加学生");
				addStudent(list);
				break;
			case "2":
				//System.out.println("删除学生");
				deleteStudent(list);
				break;
			case "3":
				//System.out.println("修改学生");
				updateStudent(list);
				break;
			case "4":
				//System.out.println("查看学生");
				queryStudents(list);
				break;
			case "5":
				System.out.println("感谢您的使用");
				break lo;
			default:
				System.out.println("您的输入有误");
				break;
		}
	}
}

//添加学生的方法
public static void addstudent(ArrayList<Student> list){
	Scanner sc = new Scanner(System.in);
	String sid;
	//1.给出录入的提示信息
	while(true){
		System.out.println("请输入学号：");
		sid = sc.next();
		
		int index = getIndex(list,sid);
		
		if(index == -1){
			//sid不存在，学号可以使用
			break;
		}
	}
	
	System.out.println("请输入姓名：");
	String name = sc.next();
	System.out.println("请输入年龄：");
	int age = sc.nextInt();
	System.out.println("请输入生日：");
	String birthday = sc.next();
	//2.将键盘录入的信息封装为学生对象
	Student stu  =new Student(sid,name,age,birthday);
	//3.将封装好的学生对象，添加到集合容器当中
	list.add(stu);
	//4.给出添加成功的提示信息
	System.out.println("添加成功！")；
}

public static int getIndex(ArrayList<Student> list,String sid){
	//1.假设传入的学号，在集合中不存在
	int index =-1;
	//2.遍历集合，获取每一个学生对象，准备进行查找
	for (int i = 0; i < list.size(); i++){
		Student stu = list.get(i);
		//3.获取每一个学生对象的学号
		String id = stu.getsid();
		//4.使用获取出的学生学号，和传入的学号（查找的学号）进行比对
		if(id.equals(sid)){
			//存在：让index变量记录正确的索引位置
			index = i;
		}
	}
	return index;
}