写在前面：
每一个不曾起舞的日子，都是对生命的辜负。
希望看到这里的每一个人都能努力学习，不负韶华，成就更好的自己。
以下仅是个人学习过程中的一些想法与感悟，Java知识博大精深，作为初学者，个人能力有限，哪里写的不够清楚、明白，还请各位不吝指正，欢迎交流与讨论。如果有朋友因此了解了一些知识或对Java有了更深层次的理解，从而进行更进一步的学习，那么这篇文章的意义也就达到了。
目录
常用API(String、ArrayList)
什么是API?
API （Application Programming Interface,应用程序编程接口）
⚫ Java写好的技术(功能代码)，可以直接调用。
⚫ Oracle 也为Java提供的这些功能代码提供了相应的 API文档(技术使用说明书) 。
String简单介绍
String类定义的变量可以用于存储字符串，同时String类提供了很多操作字符串的功能，我们可以直接使用。
ArrayList简单介绍
⚫ ArrayList代表的是集合类，集合是一种容器，与数组类似，不同的是集合的大小是不固定的。
⚫ 通过创建ArrayList对象表示得到一个集合容器，同时ArrayList提供了比数组更好用，更丰富的API（功能）供程序员使用。
一、String
1.1String类概述
⚫ java.lang.String 类代表字符串，String类定义的变量可以用于指向字符串对象，然后操作该字符串。
⚫ Java 程序中的所有字符串文字（例如“abc”）都为此类的对象。
String类的特点详解
String其实常被称为不可变字符串类型，它的对象在创建后不能被更改。以””方式给出的字符串对象，在字符串常量池中存储。
示例代码如下：
public static void main(String[] args) {
String name = "张三";
name += "李四";
name += "王五";
System.out.println(name); // 张三李四王五
}其内存执行机制如下：
Step1：首先执行main()方法,将main()方法添加到栈内存中，然后执行第一行代码，在栈内存中开辟一块空间用于存储变量name中的数据，在堆内存中的字符串常量池中生成字符串对象”张三”，再将该对象的地址传给name变量存储，在后续访问时通过变量name中存储的地址访问该字符串（String类型比较特殊，打印时不打印地址，而是打印地址指向的字符串的值，在后续继承章节会讲解）。
Step2：执行第二行代码，在堆内存中的字符串常量池中生成字符串对象”李四”，后与name中地址指向的字符串”张三”运算衔接，生成新的字符串”张三李四”，存储到堆内存中（非字符串常量池，因为是运算生成的而不是定义的），再将生成的新的字符串”张三李四”的地址赋给name变量存储（“张三”、”李四”两个对象在创建后并没有改变，只是String类型的变量name指向了新的对象的地址）。
Step3：执行第三行代码，原理同第二行。
Step4：执行第四行代码，将此时String类型变量name中存储的”张三李四王五”（实际上存储的该对象的地址值）打印出来。
1.2String类创建对象的2种方式
方式一：直接使用””定义。（推荐方式）
方式二：通过String类的构造器创建对象。
通过String类的构造器创建对象
| 构造器 | 说明 |
| public String() | 创建一个空白字符串对象，不含有任何内容（几乎不用） |
| public String(String) | 根据传入的字符串内容，来创建字符串对象（几乎不用） |
| public String(char[] c) | 根据字符数组的内容，来创建字符串对象 |
| public String(byte[] b) | 根据字节数组的内容，来创建字符串对象 |
示例代码如下：
public static void main(String[] args) {
// 方式一：直接使用””定义（推荐方式）
String name = "张三";
// 方式二 通过String类的构造器创建对象
// 1.public String() 创建一个空白字符串对象，不含有任何内容（几乎不用）
String s1 = new String();
System.out.println(s1); // 打印结果为空白(不是null)
// 2.public String(String) 根据传入的字符串内容，来创建字符串对象（几乎不用）
String s2 = new String("张三");
// 3.public String(char[] c) 根据字符数组的内容，来创建字符串对象
char[] chars = {'a', 'b', '张', '三'};
String s3 = new String(chars); // 内部自动把字符数组的内容连接到一起
System.out.println(s3); // ab张三
// 4.public String(byte[] b) 根据字节数组的内容，来创建字符串对象
byte[] bytes = {33, 97, 65, 102};
String s4 = new String(bytes); // 内部自动把字节数组的内容转换成字符型然后连接到一起
System.out.println(s4); // !aAf
}两种构造方式的区别？
以””方式定义的字符串对象，在字符串常量池中存储，而且相同内容只会存储一份。
通过构造器new出来的对象，每new一次都会产生一个新的对象，放在堆内存中。
示例代码如下：
// 两种构造方式的区别？
// 以””方式定义的字符串对象，在字符串常量池中存储，而且相同内容只会存储一份
String string1 = "abc";
String string2 = "abc";
System.out.println(string1 == string2); // true，变量中存储的是地址，二者地址相同
// 通过构造器new出来的对象，每new一次都会产生一个新的对象，放在堆内存中
char[] chars2 = {'a', 'b', 'c', 'd'};
String string3 = new String(chars2);
String string4 = new String(chars2);
System.out.println(string3 == string4); // false 每次new出来的对象地址均不同Java存在编译优化机制，程序在编译时，”a” + ”b” + ”c”（都是字面量参与运算，不含变量）会直接转换成”abc”。
示例代码如下：
// 注：Java存在编译优化机制，程序在编译时，”a” + ”b” + ”c”（都是字面量参与运算，不含变量）会直接转换成”abc”。
String string5 = "abc";
String string6 = "a" + "b" + "c";
System.out.println("string5 == string6:" + (string5 == string6)); // true
String string7 = "ab";
String string8 = string7 + "c"; // 有变量参与，仍然在堆内存中生成新的对象，而不是在字符串常量池中优化衔接
System.out.println("string7 == string8:" + (string7 == string8)); // false注：在工程文件的out文件夹中可以找到.java文件编译后的.class文件，查看编译后（实际运行）的源代码。
1.3String类常用API-字符串内容比较
现有如下代码：
public static void main(String[] args) {
// 正确登录名和密码
String loginName = "张三";
String loginPassword = "123456";
// 用户输入登录名和密码
Scanner sc = new Scanner(System.in);
System.out.println("请输入登陆名：");
String name = sc.next();
System.out.println("请输入登陆密码：");
String password = sc.next();
// 判断用户输入的账号、密码是否正确
if ((loginName == name) & (loginPassword == password)) { // false 字符串内容比较不适合用"=="
System.out.println("登陆成功");
} else {
System.out.println("用户名或密码错误");
}
}输入登录名：张三，登陆密码：123456
由于正确登录名、密码是在堆内存中的字符串常量池中生成的，用户输入的登录名、密码是在堆内存中new出来的对象在堆内存中生成（接收）的，二者地址肯定不同，因此字符串内容比较不适合用"=="
字符串内容比较：
推荐使用String类提供的“equals”比较：只关心内容一样即可
常用API-字符串内容比较
| 方法名 | 说明 |
| public boolean equals (Object an Object) | 将此字符串与指定对象进行比较。只关心字符内容是否一致 |
| public boolean equalsIgnoreCase (String anotherString) | 将此字符串与指定对象进行比较，忽略大小写比较字符串。只关心字符内容是否一致 |
示例代码如下：
Scanner sc = new Scanner(System.in);
String loginCode = "Abc123";
System.out.println("请输入验证码：");
String code = sc.next(); // ABC123
System.out.println(loginCode.equals(code)); // false equals()是精确比较
System.out.println(loginCode.equalsIgnoreCase(code)); // true equalsIgnoreCase()是忽略字母大小写比较注：”==”与”equals()”两种类型的比较方式如何选择？
基本数据类型变量中存储的是具体值，其比较常使用”==”，引用数据类型如String类型中存放的是地址，有可能会出现地址不一样但两个地址指向的具体数据一样的情况，因此其比较常用”equals()”。
1.4String类常用API-遍历、替换、截取、分割操作
String常用API
| 方法名 | 说明 |
| public int length() | 返回此字符串的长度 |
| public char charAt(int index) | 获取某个索引位置处的字符 |
| public char[] toCharArray() | 将当前字符串转换成字符数组返回 |
| public String substring(int beginIndex, int endIndex) | 根据开始和结束索引进行截取，得到新的字符串 （左闭右开） |
| public String substring(int beginIndex) | 从传入的索引处截取，截取到末尾，得到新的字符串 |
| public String replace(CharSequence target, CharSequence replacement) | 使用新值，将字符串中的旧值替换，得到新的字符串 |
| public String[] split(String regex) | 根据传入的规则切割字符串，得到字符串数组返回 |
| public boolean contains(CharSequence s) | 判断字符串中是否包含该关键字 |
| public boolean startsWiths(String prefix) | 判断字符串是否以该关键字为前缀 |
示例代码如下：
public static void main(String[] args) {
// 1.public int length() 返回此字符串的长度
String name = "我爱你中国China";
int length = name.length(); // 获取字符串name的长度
System.out.println("\"我爱你中国China\"的长度是" + length);
// 2.public char charAt(int index) 获取某个索引位置处的字符
char ai = name.charAt(1); // 获取字符串name中第1个索引位置的字符
System.out.println("\"我爱你中国China\"中第2个字符为：" + ai);
System.out.println("----------遍历字符串中的每一个字符------------");
for (int i = 0; i < name.length(); i++) {
System.out.print(i == name.length() - 1 ? name.charAt(i) + "\n" : name.charAt(i) + "\t");
}
// 3.public char[] toCharArray() 将当前字符串转换成字符数组返回
char[] chars = name.toCharArray(); // 把字符串name中的每个字符都放到了字符型数组chars中的各个索引位置
for (int i = 0; i < chars.length; i++) {
System.out.print(i == chars.length - 1 ? chars[i] + "\n" : chars[i] + "\t");
}
// 4.public String substring(int beginIndex, int endIndex) 根据开始和结束索引进行截取，得到新的字符串（左闭右开）
String name2 = "Java是最厉害的编程语言！";
String rs1 = name2.substring(0, 9); // 截取第0-8位
System.out.println(rs1); // Java是最厉害的
String rs2 = name2.substring(5, 14); // 截取第5-13位
System.out.println(rs2); // 最厉害的编程语言！
// 5.public String substring(int beginIndex) 从传入的索引处截取，截取到末尾，得到新的字符串
String rs3 = name2.substring(4); // 截取第4位至末尾
System.out.println(rs3); // 是最厉害的编程语言！
// 6.public String replace(CharSequence target, CharSequence replacement) 使用新值，将字符串中的旧值替换，得到新的字符串 CharSequence等同于String
String name3 = "金三胖是最厉害的80后，金三胖胖胖的，我好爱金三胖！";
String rs4 = name3.replace("金三胖", "***"); // 将字符串name3中的"金三胖"全部替换为"***"，其中第一个参数是被替换的关键字，第二个参数为替换后的关键字
System.out.println(rs4); // ***是最厉害的80后，***胖胖的，我好爱***！
// 7.public String[] split(String regex) 根据传入的规则切割字符串，得到字符串数组返回
String personName = "张三,李四,王五,赵六";
String names[] = personName.split(","); // 根据","将字符串切割，每一部分都添加到数组中的各个索引位置
System.out.print("姓名为：");
for (int i = 0; i < names.length; i++) {
System.out.print(i == names.length - 1 ? names[i] + "\n" : names[i] + "\t"); // 张三 李四 王五 赵六
}
// 8.public boolean contains(CharSequence s) 判断字符串中是否包含该关键字
boolean isContain = name3.contains("金三胖");
System.out.println(isContain); // true
// 9.public boolean startsWiths(String prefix) 判断字符串是否以该关键字为前缀
System.out.println(name3.startsWith("金三胖")); // true
System.out.println(name3.startsWith("金三胖是")); // true
System.out.println(name3.startsWith("金三胖是1")); // false
}1.5String案例操作
1.5.1String类开发验证码功能
需求：随机产生一个5位的验证码，每位可能是数字、大写字母、小写字母。
分析：
① 定义一个String类型的变量存储验a-zA-Z0-9之间的全部字符。
② 循环5次，随机一个范围内的索引，获取对应字符连接起来即可。
示例代码如下：
public static void main(String[] args) {
// 定义可能出现的字符信息
String data = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
// 循环5次，每次生成一个随机的索引，提取对应的字符，连接起来即可
Random r = new Random();
String code = ""; // 定义一个变量，用于存储验证码，初始值为空
for (int i = 0; i < 5; i++) {
int index = r.nextInt(data.length()); // 在字符串长度内，随机一个索引
code += data.charAt(index);
}
System.out.println("随机生成的验证码是：" + code);
}1.5.2模拟用户登陆功能
需求：模拟用户登录功能，最多只给三次机会。
分析：
① 系统后台定义好正确的登录名称，密码。
② 使用循环控制三次，让用户输入正确的登录名和密码，判断是否登录成功，登录成功则不再进行登录；登录失败给出提示，并让用户继续登录。
示例代码如下：
public static void main(String[] args) {
// 定义正确的登陆名称和密码
String loginName = "admin";
String loginPassword = "admin";
// 定义一个循环，让用户登陆，最多循环3次
Scanner sc = new Scanner(System.in);
for (int i = 0; i < 3; i++) {
System.out.println("您还有" + (3 - i) + "次登陆机会");
System.out.println("请输入用户名：");
String name = sc.next();
System.out.println("请输入密码：");
String password = sc.next();
// 判断登陆是否成功
if (loginName.equals(name)) {
if (loginPassword.equals(password)) {
System.out.println("登陆成功！");
break;
} else {
System.out.println("密码错误，请重新输入！");
}
} else {
System.out.println("账号不存在，请重新输入");
}
}
}1.5.3手机号码加密
需求：键盘录入一个手机号，将中间四位号码屏蔽，最终效果为：
分析：
① 键盘录入一个字符串。
② 调用字符串对象的截取API，截取字符串前三位、后四位。
③ 将前三位 连接“****”然后继续连接后四位，输出最终结果即可。
示例代码如下：
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (true) {
System.out.println("请输入手机号码：");
// 键盘录入手机号码
String telNumber = sc.next();
//判断号码是否为11位，如果不是则给出提示并重新输入
if (telNumber.length() != 11) {
System.out.println("您输入的号码错误，请输入11位的数字！");
} else {
// 截取号码的前三位和后四位
String telSubstring1 = telNumber.substring(0, 3); // 截取前三位
String telSubstring2 = telNumber.substring(7); // 截取后四位
System.out.println("加密后的手机号码为" + telSubstring1 + "****" + telSubstring2);
break;
}
}
}二、ArrayList
数组与集合的异同：
同：集合与数组类似，也是一种容器，用于装数据。
异：①数组定义完成并启动后，类型确定，长度固定。集合的大小不固定，启动后可以动态变化，类型也可以选择不固定。
②数组功能比较单一，集合提供了许多丰富、好用的功能。
③数组适合做个数和类型确定的场景。集合适合做元素个数不确定且需要进行增删改查的业务场景。
2.1ArrayList集合快速入门
ArrayList是集合中的一种，它支持索引。
ArrayList集合的对象获取
| 构造器 | 说明 |
| public ArrayList() | 创建一个空的集合对象 |
ArrayList集合添加元素的方法
| 方法名 | 说明 |
| Public boolean add(E e) | 将指定的元素追加到此集合的末尾 |
| Public void add(int index, E element) | 在此集合中的指定位置插入指定的元素 |
示例代码如下：
public static void main(String[] args) {
// 实例化ArrayList集合的对象
ArrayList list = new ArrayList();
// 向ArrayList集合中添加数据
list.add("Java");
// System.out.println(list.add("Java")); // true
list.add("MySQL");
list.add(122);
list.add('中');
list.add(true);
System.out.println(list); // [Java, MySQL, 122, 中, true] 变量中存储的仍然是ArrayList对象的地址，但是经过改进后可以打印出其中存储的内容
// 给指定索引位置添加元素
list.add(2,100); // 在第二个索引位置添加数据100
System.out.println(list); // [Java, MySQL, 100, 122, 中, true] 其他数据向后顺延，而不是被替换掉
}2.2ArrayList对于泛型的支持
泛型概述：
ArrayList<E>就是一个泛型类，可以在编译阶段约束集合对象只能操作某种数据类型。
如ArrayList<String>：此集合只能操作字符串类型的元素。ArrayList<Integer>：此集合只能操作整数类型的元素。
注：集合中泛型声明只能存储引用类型，不支持基本数据类型。
示例代码如下：
ArrayList list = new ArrayList(); // 实例化对象时没有使用泛型约束，在此集合内可以添加任意类型的数据
list.add("Java");
list.add(120);
ArrayList<String> list2 = new ArrayList<String>();// 使用泛型约束，在此集合内仅可以添加String类型的数据
ArrayList<String> list3 = new ArrayList<>(); // JDK1.7开始，后面的泛型类型声明可以不写
list2.add("Java");
// list2.add(120); // 报错，数据类型只能是String
// ArrayList<int> list4 = new ArrayList<>(); // 报错，集合中泛型声明只能存储引用类型，不支持基本数据类型。
ArrayList<Integer> list4 = new ArrayList<>(); // Integer相当于int的引用类型
list4.add(10);
// list4.add("apple"); // 报错，数据类型只能是Integer
}2.3ArrayList常用API、遍历
ArrayList集合常用API
| 方法名称 | 说明 |
| public E get(int index) | 返回指定索引处的元素 |
| public int size() | 返回集合中的元素的个数 |
| public E remove(int index) | 删除指定索引处的元素，返回被删除的元素 |
| public boolean remove(Object o) | 删除指定的元素，返回删除是否成功 |
| public E set(int index,E element) | 修改指定索引处的元素，返回被修改的元素 |
注：当元素中有一模一样的元素时，remove(Object o)默认删除第一次出现的元素
示例代码如下：
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("Java");
list.add("Java");
list.add("MySQL");
list.add("MyBatis");
list.add("HTML");
// 1.public E get(int index) 返回指定索引处的元素
String e = list.get(3);
System.out.println(e); // MyBatis
// 2.public int size() 返回集合中的元素的个数
int length = list.size();
System.out.println(length); // 5
// 完成集合的遍历
System.out.print("集合中的元素为：");
for (int i = 0; i < list.size(); i++) {
System.out.print(i == list.size() - 1 ? list.get(i) + "\n" : list.get(i) + "\t");
}
// 3.public E remove(int index) 删除指定索引处的元素，返回被删除的元素
System.out.println(list); // [Java, Java, MySQL, MyBatis, HTML]
String e2 = list.remove(2);
System.out.println(e2); // MySQL
System.out.println(list); // [Java, Java, MyBatis, HTML] 此时集合中索引为2的元素已经被删除，集合总长度相应-1
// 4.public boolean remove(Object o) 删除指定的元素，返回删除是否成功
boolean isDelete = list.remove("MyBatis");
System.out.println(isDelete); // true
System.out.println(list); // [Java, Java, HTML]
list.remove("Java");
System.out.println(list); // [Java, HTML] 当元素中有一模一样的元素时，remove(Object o)默认删除第一次出现的元素
// 5.public E set(int index,E element) 修改指定索引处的元素，返回被修改的元素
System.out.println(list); // [Java, HTML]
String e3 = list.set(0, "张三");
System.out.println(e3); // Java
System.out.println(list); // [张三, HTML]
}2.4ArrayList集合案例：遍历并删除元素
需求：某个班级的考试在系统上进行，成绩大致为：98, 77, 66, 89, 79, 50, 100，现在需要先把成绩低于80分以下的数据去掉。
分析：
① 定义ArrayList集合存储多名学员的成绩。
② 遍历集合每个元素，如果元素值低于80分，去掉它。
示例代码如下：
public static void main(String[] args) {
// 创建一个ArrayList集合存储班级中学生的成绩
ArrayList<Integer> scores = new ArrayList<>();
scores.add(98);
scores.add(77);
scores.add(66);
scores.add(89);
scores.add(79);
scores.add(50);
scores.add(100);
System.out.println(scores); // [98, 77, 66, 89, 79, 50, 100]
// 把低于80分的成绩从集合中去掉
// 错误代码
// for (int i = 0; i < scores.size(); i++) {
// int score = scores.get(i);
// if (score <= 80) {
// scores.remove(i); // 直接删除第i个索引元素，集合数目发生变化，后续索引向前顺延，遍历发生越位，导致没有完全遍历到所有元素，出现错误
// }
// }
// System.out.println(scores); // [98, 66, 89, 50, 100]
// 正确代码一：删除后退位，保证i++后回到当前位置
// for (int i = 0; i < scores.size(); i++) {
// int score = scores.get(i);
// if (score <= 80) {
// scores.remove(i);
// i--; // 删除某个元素后，使i向前退一位，正好弥补越位情况
// }
// }
// System.out.println(scores); // [98, 89, 100]
// 正确代码二：从后往前遍历、删除
for (int i = scores.size() - 1; i >= 0; i--) {
int score = scores.get(i);
if (score <= 80) {
scores.remove(i); // 每次从后向前遍历，删除某个元素，不会改变其之前元素的索引，不会发生越位情况
}
}
System.out.println(scores); // [98, 89, 100]
}2.5ArrayList集合案例：存储自定义类型的对象
需求：某影院系统需要在后台存储上述三部电影，然后依次展示出来。
分析：
① 定义一个电影类，定义一个集合存储电影对象。
② 创建3个电影对象，封装相关数据，把3个对象存入到集合中去。
③ 遍历集合中的3个对象，输出相关信息。
示例代码如下：
测试类：
public class ArrayListTest5 {
public static void main(String[] args) {
// 定义电影类
// 创建3个电影对象，用于封装电影信息
Movie m1 = new Movie("肖申克的救赎", 9.7, "罗宾斯");
Movie m2 = new Movie("霸王别姬", 9.6, "张国荣、张丰毅");
Movie m3 = new Movie("阿甘正传", 9.5, "汤姆.汉克斯");
// 创建一个Movie类型的ArrayList集合，将3个对象放到集合中
ArrayList<Movie> list = new ArrayList<>();
list.add(m1);
list.add(m2);
list.add(m3);
System.out.println(list); // 3个Movie类型对象的地址
// 遍历Movie类型的集合中的每个Movie对象，访问其内容
System.out.println("电影名\t\t评分\t\t主演");
for (int i = 0; i < list.size(); i++) {
System.out.print(list.get(i).getName() + "\t\t");
System.out.print(list.get(i).getScore() + "\t\t");
System.out.println(list.get(i).getActor());
}
}
}注：集合中存储的元素并不是对象本身，而是对象的地址。
2.6ArrayList集合案例：元素搜索
需求：后台程序需要存储如上学生信息并展示，然后要提供按照学号搜索学生信息的功能。
分析：
① 定义Student类，定义ArrayList集合存储如上学生对象信息，并遍历展示出来。
② 提供一个方法，可以接收ArrayList集合，和要搜索的学号，返回搜索到的学生对象信息，并展示。
③ 使用死循环，让用户可以不停的搜索。
示例代码如下：
测试类：
public class ArrayListTest6 {
public static void main(String[] args) {
// 创建学生类
// 创建学生对象，封装学生信息
Student stu1 = new Student("20180302", "叶孤城", 23, "护理一班");
Student stu2 = new Student("20180303", "东方不败", 23, "护理一班");
Student stu3 = new Student("20180304", "西门吹雪", 26, "护理一班");
Student stu4 = new Student("20180305", "梅超风", 26, "护理一班");
// 创建一个Movie类型的ArrayList集合，将4个对象放到集合中
ArrayList<Student> stuList = new ArrayList<>();
stuList.add(stu1);
stuList.add(stu2);
stuList.add(stu3);
stuList.add(stu4);
// 遍历Student类型的集合中的每个Student对象，访问其内容
System.out.println("学号\t\t姓名\t\t年龄\t\t班级");
for (int i = 0; i < stuList.size(); i++) {
System.out.println(stuList.get(i).getStdNo() + "\t" + stuList.get(i).getName() + "\t" + stuList.get(i).getAge() + "\t" + stuList.get(i).getClassName());
}
// 定义方法完成按照学号搜索的功能
// 定义死循环，调用按照学号搜索的方法，完成搜索
Scanner sc = new Scanner(System.in);
while (true) {
System.out.println("请输入要查询的学号:");
String stdNo = sc.next();
Student student = getStudentById(stuList, stdNo); // 调用按照学号搜索的方法，返回学生对象或null
// 判断返回值是否为null，若返回值不是null,将该学生对象的各项信息打印输出，否则给出相应提示
if (student != null) {
System.out.println("查询结果如下");
System.out.println("学号\t\t姓名\t\t年龄\t\t班级");
System.out.println(student.getStdNo() + "\t" + student.getName() + "\t" + student.getAge() + "\t" + student.getClassName());
} else {
System.out.println("很抱歉，没有相关信息");
}
}
}
/**
* create by: 全聚德在逃烤鸭、
* description: 根据学生学号查询学生对象并返回
* create time: 2022/4/8 0008 21:26
*
* @param stuList 存储全部学生对象的集合
* @param stdNo 搜索的学生学号
* @return com.itheima.arraylist.Student 学生对象 | null
*/
public static Student getStudentById(ArrayList<Student> stuList, String stdNo) {
// 遍历全部学生对象
for (int i = 0; i < stuList.size(); i++) {
Student student = stuList.get(i); // 定义一个Student类型变量student，用于存储集合中当前第i个学生对象元素
// 判断当前第i个索引位置的学生对象中的学生学号与要搜索的学生学号是否一致，若一致，则将当前学生对象返回，否则继续遍历
if (student.getStdNo().equals(stdNo)) { // 判断内容是否一致
return student; // 将第i个索引位置的学生对象返回
}
}
return null; // 遍历结束后，没有找到符合条件的学生对象，返回null
}
}
写在最后：
感谢读完！
纵然缓慢，驰而不息！加油！
扫一扫
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
