>[success] # ArrayList 增删改查案例
1. List 作为 ArrayList的接口 实现了List 中接口的方法，同样具备一下操作
2. `ArrayList() `,创建一个长度为0的集合
* `boolean add(E e) 添加`
* `boolean remove(E e) 删除`
* `E remove(int index) 删除指定位置`
* `E set(int index,E e) 修改`
* `E get(int index) 查询`
* `int size() 获取长度`
~~~
import java.util.ArrayList;
public class ArrayListTest {
public static void main(String[] args) {
/*
* boolean add(E e) 添加
*
* boolean remove(E e) 删除
* E remove(int index)
*
* E set(int index,E e) 修改
*
* E get(int index) 查询
* int size() 获取长度
*
*/
ArrayList<String> list = new ArrayList<>();
list.add("aaa");
list.add("bbb");
list.add("ccc");
list.add("ddd");
// 删除内容
boolean remove1 = list.remove("aaa");
System.out.print(remove1); // true
// 通过序号删除内容
String rm = list.remove(0);
System.out.println(rm); // bbb
// 修改指定位置内容
String update = list.set(0, "123");
System.out.print(update); // ccc 返回被修改内容
// 获取指定位置内容
String str = list.get(0);
System.out.print(str); // 123
// 获取长度
int len = list.size();
System.out.print(len); // 2
}
}
~~~
>[danger] ## 集合中包装类
1. 数组可以保存基本类型或者引用类型，集合是引用类型，如果保存基本类型需要使用其**包装类**
~~~
import java.util.ArrayList;
public class ArrayListTest {
public static void main(String[] args) {
// 定义保存int 类型数据 就需要使用int 的包装类Integer
ArrayList<Integer> intLs = new ArrayList<>();
// 增
intLs.add(1);
intLs.add(2);
// 删 指定内容值
Integer i = 1;
intLs.remove(i);
// 删除指定位置的值
intLs.remove(0);
// 获取长度
int size = intLs.size();
System.out.print(size); // 0
// 新增后更新值
intLs.add(789);
intLs.set(0, 1223456);
// 打印值
Integer ii = intLs.get(0);
System.out.print(ii); // 1223456
}
}
~~~
>[info] ## 简单学生管理
1. 具备可以手动输入学生数据
2. 可以根据学号查找某个学生是否存在
3. 可以打印出某个学号学生的具体信息
4. 可以统计成绩不及格人数据打印
5. 可以打印所有学生数据
>[danger] ##### 创建学生的javaBean -- Student
~~~
public class Student {
// 私有化成员变量
private int id;
private String name;
private int age;
private int scores;
// 构造方法
public Student(int id, String name, int age, int scores) {
this.id = id;
this.name = name;
this.age = age;
this.scores = scores;
}
public Student() {
}
// get/set方法
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
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 getScores() {
return scores;
}
public void setScores(int scores) {
this.scores = scores;
}
}
~~~
>[danger] ##### 实现功能的方法类 -- StudentTest
~~~
import java.util.ArrayList;
import java.util.Scanner;
import javax.swing.text.html.HTMLDocument.RunElement;
/**
*
* 1. 具备可以手动输入学生数据
* 2. 可以根据学号查找某个学生是否存在
* 3. 可以打印出某个学号学生的具体信息
* 4. 可以统计成绩不及格人数据打印
* 5. 可以打印所有学生数据
*/
public class StudentTest {
public static void main(String[] args) {
// 开始录入
Scanner sc = new Scanner(System.in);
System.out.println("请输入录入人数");
int count = sc.nextInt();
// 获取录入list
ArrayList<Student> students = enterStudentsInfo(count);
// 输入要查找id
System.out.println("输入要查找id");
int id = sc.nextInt();
if (contains(students, id)) {
int index = getIndexById(students, id);
Student stu = students.get(index);
System.out.print(stu.getName());
} else {
System.out.println("当前学生不存在");
}
}
// 录入学生
public static ArrayList<Student> enterStudentsInfo(int count) {
Scanner sc = new Scanner(System.in);
// 创建一个录入集合
ArrayList<Student> studentLs = new ArrayList<>();
for (int i = 0; i < count; i++) {
Student stu = new Student();
System.out.println("输入学生ID");
int Id = sc.nextInt();
stu.setId(Id);
System.out.println("请输入学生名字");
String name = sc.next();
stu.setName(name);
System.out.println("请输入学生年龄");
int age = sc.nextInt();
stu.setAge(age);
System.out.print("请输入学生分数");
double scores = sc.nextDouble();
stu.setScores(scores);
// 保存学生
studentLs.add(stu);
}
return studentLs;
}
// 根据Id 获得索引位置
public static int getIndexById(ArrayList<Student> arr, int id) {
for (int i = 0; i < arr.size(); i++) {
Student stu = arr.get(i);
if (stu.getId() == id) {
return i;
}
}
return -1;
}
// 是否包含
public static boolean contains(ArrayList<Student> arr, int id) {
return getIndexById(arr, id) >= 0;
}
// 获取不及格信息
public static ArrayList<Student> getLtSources60(ArrayList<Student> arr) {
ArrayList<Student> stuLs = new ArrayList<>();
for (int i = 0; i < arr.size(); i++) {
Student stu = arr.get(i);
double sources = stu.getScores();
if (sources < 60) {
stuLs.add(stu);
}
}
return stuLs;
}
}
~~~
>[info] ## 用户登录注册
1. 学生管理系统书写一个登陆、注册、忘记密码的功能
2. 需求文档:
* 用户类： 属性：用户名、密码、身份证号码、手机号码
* 注册功能：
用户名唯一
用户名长度必须在3~15位之间
只能是字母加数字的组合，但是不能是纯数字
密码键盘输入两次，两次一致才可以进行注册。
身份证号码需要验证,**长度为18位,不能以0为开头,前17位，必须都是数字,最后一位可以是数字，也可以是大写X或小写x**
手机号验证**长度为11位不能以0为开头必须都是数字**
* 登录功能：键盘录入用户名，键盘录入密码，键盘录入验证码
**验证要求**：用户名如果未注册，直接结束方法，并提示：用户名未注册，请先注册
，判断验证码是否正确，如不正确，重新输入再判断用户名和密码是否正确，有3次机会
* 忘记密码：键盘录入用户名，判断当前用户名是否存在，如不存在，直接结束方法，并提示：未注册。键盘录入身份证号码和手机号码，判断当前用户的身份证号码和手机号码是否一致，如果一致，则提示输入密码，进行修改。如果不一致，则提示：账号信息不匹配，修改失败。
* 验证码规则：长度为5，由4位大写或者小写字母和1位数字组成，同一个字母可重复
数字可以出现在任意位置
>[danger] ##### 创建用户的javaBean类 -- User
~~~
public class User {
// 定义私有变量
private String name;
private String password;
private String personID;
private String phoneNum;
// 创建有参无参构造
public User() {
}
public User(String name, String password, String personID, String phoneNum) {
this.name = name;
this.password = password;
this.personID = personID;
this.phoneNum = phoneNum;
}
// 使用访问的get set 方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getPersonID() {
return personID;
}
public void setPersonID(String personID) {
this.personID = personID;
}
public String getPhoneNum() {
return phoneNum;
}
public void setPhoneNum(String phoneNum) {
this.phoneNum = phoneNum;
}
}
~~~
>[danger] ##### 登录界面
~~~
import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;
public class UserTest {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
// 保存记录的list
ArrayList<User> ls = new ArrayList<>();
while (true) {
// 绘制注册页面
System.out.println("欢迎来到学生管理系统");
System.out.println("请选择操作：1登录 2注册 3忘记密码");
// 开始进行分配
String choose = sc.next();
switch (choose) {
case "1" -> login(ls);
case "2" -> register(ls);
case "3" -> forgetPassword(ls);
case "4" -> {
System.out.println("谢谢使用，再见");
System.exit(0);// 强制退出
}
default -> System.out.println("没有这个选项");
}
}
}
private static void printList(ArrayList<User> list) {
for (int i = 0; i < list.size(); i++) {
// i 索引
User user = list.get(i);
System.out.println(user.getName() + ", " + user.getPassword() + ", "
+ user.getPersonID() + ", " + user.getPhoneNum());
}
}
public static void login(ArrayList<User> list) {
Scanner sc = new Scanner(System.in);
for (int i = 0; i < 3; i++) {
System.out.println("请输入用户名");
String username = sc.next();
// 判断用户名是否存在
boolean flag = contains(list, username);
if (!flag) {
System.out.println("用户名" + username + "未注册，请先注册再登录");
return;
}
System.out.println("请输入密码");
String password = sc.next();
while (true) {
String rightCode = getCode();
System.out.println("当前正确的验证码为：" + rightCode);
System.out.println("请输入验证码");
String code = sc.next();
if (code.equalsIgnoreCase(rightCode)) {
System.out.println("验证码正确");
break;
} else {
System.out.println("验证码错误");
continue;
}
}
// 验证用户名和密码是否正确
// 集合中是否包含用户名和密码
// 定义一个方法验证用户名和密码是否正确
// 封装思想的应用：
// 我们可以把一些零散的数据，封装成一个对象
// 以后传递参数的时候，只要传递一个整体就可以了，不需要管这些零散的数据。
User useInfo = new User(username, password, null, null);
boolean result = checkUserInfo(list, useInfo);
if (result) {
System.out.println("登录成功，可以开始使用学生管理系统了");
break;
} else {
System.out.println("登录失败，用户名或密码错误");
if (i == 2) {
System.out.println("当前账号" + username + "被锁定，请联系黑马程序员客服：XXX-XXXXX");
// 当前账号锁定之后，直接结束方法即可
return;
} else {
System.out.println("用户名或密码错误，还剩下" + (2 - i) + "次机会");
}
}
}
}
public static void register(ArrayList<User> ls) {
Scanner sc = new Scanner(System.in);
/*
* 校验用户名
* 用户名长度必须在3~15位之间
* 只能是字母加数字的组合，但是不能是纯数字
*
* 整个用户名也可能不是一次输入对的因此需要循环
*/
String username;
while (true) {
System.out.println("请输入用户名称");
username = sc.next();
boolean flagName = checkUsername(username);
// 不满足需要重新输入用户名
if (!flagName) {
System.out.println("用户名格式不满足条件，需要重新输入");
continue;
}
// 校验用户名是否唯一
boolean flag2 = contains(ls, username);
if (flag2) {
// 用户名已存在，那么当前用户名无法注册，需要重新输入
System.out.println("用户名" + username + "已存在，请重新输入");
} else {
// 不存在，表示当前用户名可用，可以继续录入下面的其他数据
System.out.println("用户名" + username + "可用");
break;
}
}
// 密码键盘输入两次，两次一致才可以进行注册
String pwd;
while (true) {
System.out.println("请输入要注册的密码");
pwd = sc.next();
System.out.println("请再次输入要注册的密码");
String aginPwd = sc.next();
if (!pwd.equals(aginPwd)) {
System.out.println("两次密码输入不一致，请重新输入");
continue;
}
System.out.println("两次密码一致，继续录入其他数据");
break;
}
// 身份证号码需要验证。
// 验证要求：
// 长度为18位
// 不能以0为开头
// 前17位，必须都是数字
// 最为一位可以是数字，也可以是大写X或小写x
String id;
while (true) {
System.out.println("请输入身份证号码");
id = sc.next();
if (checkPersonId(id)) {
break;
} else {
System.out.println("身份证号码格式有误，请重新输入");
continue;
}
}
// 手机号验证。
// 验证要求：
// 长度为11位
// 不能以0为开头
// 必须都是数字
String phoneNum;
while (true) {
System.out.println("请输入手机号码");
phoneNum = sc.next();
boolean flag = checkPhoneNum(phoneNum);
if (flag) {
break;
} else {
System.out.println("手机号码格式有误，请重新输入");
}
}
// 用户名，密码，身份证号码，手机号码放到用户对象中
User u = new User(username, pwd, id, phoneNum);
// 把用户对象添加到集合中
ls.add(u);
System.out.println("注册成功");
printList(ls);
};
public static void forgetPassword(ArrayList<User> list) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入用户名");
String username = sc.next();
boolean flag = contains(list, username);
if (!flag) {
System.out.println("当前用户" + username + "未注册，请先注册");
return;
}
// 键盘录入身份证号码和手机号码
System.out.println("请输入身份证号码");
String personID = sc.next();
System.out.println("请输入手机号码");
String phoneNumber = sc.next();
// 需要把用户对象通过索引先获取出来。
int index = findIndex(list, username);
User user = list.get(index);
// 比较用户对象中的手机号码和身份证号码是否相同
if (!(user.getPersonID().equalsIgnoreCase(personID) && user.getPhoneNum().equals(phoneNumber))) {
System.out.println("身份证号码或手机号码输入有误，不能修改密码");
return;
}
// 当代码执行到这里，表示所有的数据全部验证成功，直接修改即可
String password;
while (true) {
System.out.println("请输入新的密码");
password = sc.next();
System.out.println("请再次输入新的密码");
String againPassword = sc.next();
if (password.equals(againPassword)) {
System.out.println("两次密码输入一致");
break;
} else {
System.out.println("两次密码输入不一致，请重新输入");
continue;
}
}
// 直接修改即可
user.setPassword(password);
System.out.println("密码修改成功");
}
private static int findIndex(ArrayList<User> list, String username) {
for (int i = 0; i < list.size(); i++) {
User user = list.get(i);
if (user.getName().equals(username)) {
return i;
}
}
return -1;
}
private static boolean checkUserInfo(ArrayList<User> list, User useInfo) {
// 遍历集合，判断用户是否存在，如果存在登录成功，如果不存在登录失败
for (int i = 0; i < list.size(); i++) {
User user = list.get(i);
if (user.getName().equals(useInfo.getName()) && user.getPassword().equals(useInfo.getPassword())) {
return true;
}
}
return false;
}
// 校验手机号
public static boolean checkPhoneNum(String phoneNum) {
int len = phoneNum.length();
if (len != 11) {
return false;
}
if (phoneNum.startsWith("0")) {
return false;
}
for (int i = 0; i < len; i++) {
char c = phoneNum.charAt(i);
if (c < '0' || c > '9') {
return false;
}
}
return true;
}
// 校验身份证号
public static boolean checkPersonId(String id) {
int len = id.length();
if (len != 18) {
return false;
}
if (id.startsWith("0")) {
return false;
}
// 第18 位 比较特殊 可以先校验 17 位
for (int i = 0; i < len; i++) {
char c = id.charAt(i);
// 如果有一个字符不在0-9之间，那么直接返回false
if (!(c >= '0' && c <= '9')) {
return false;
}
}
// 单独校验18位置
char endC = id.charAt(id.length() - 1);
if (!(endC >= '0' && endC <= '9') && endC != 'x' && endC != 'X') {
return false;
}
return true;
}
// 校验用户名
public static boolean checkUsername(String userName) {
/*
* 用户名长度必须在3~15位之间
* 只能是字母加数字的组合，但是不能是纯数字
*/
int len = userName.length();
if (len < 3 || len > 15) {
return false;
}
// 判断是否除了数字和字母
for (int i = 0; i < len; i++) {
char c = userName.charAt(i);
if (!((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9'))) {
return false;
}
}
// 要看看实际是否包含英文
int count = 0;
for (int i = 0; i < len; i++) {
// i 索引
char c = userName.charAt(i);
if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')) {
count++;
break;
}
}
return count > 0;
}
// 是否包含
public static boolean contains(ArrayList<User> ls, String name) {
for (int i = 0; i < ls.size(); i++) {
User user = ls.get(i);
if (user.getName().equals(name)) {
return true;
}
}
return false;
}
// 生成验证码
public static String getCode() {
// 生成 a-z 和 A-z 的字符串ls
ArrayList<Character> list = new ArrayList<>();
for (int i = 0; i < 26; i++) {
list.add((char) ('a' + i));
list.add((char) ('A' + i));
}
StringBuffer sb = new StringBuffer();
Random r = new Random();
// 随机从ls 中取值
for (int i = 0; i < 4; i++) {
// 获取随机索引
int index = r.nextInt(list.size());
// 利用随机索引获取字符
char c = list.get(index);
// 把随机字符添加到sb当中
sb.append(c);
}
int number = r.nextInt(10);
sb.append(number);
// 数字是随机位置
// 先把字符串变成字符数组，在数组中修改，然后再创建一个新的字符串
char[] arr = sb.toString().toCharArray();
// 拿着最后一个索引，跟随机索引进行交换
int randomIndex = r.nextInt(arr.length);
// 最大索引指向的元素 跟随机索引指向的元素交换
char temp = arr[randomIndex];
arr[randomIndex] = arr[arr.length - 1];
arr[arr.length - 1] = temp;
return new String(arr);
}
}
~~~
- windows -- 环境变量
- Vscode -- 编写java
- 初始java
- java -- 关键字
- 编写第一个java程序
- java -- 注释
- 计算机存储 -- 进制
- java -- 类型
- java -- 变量
- 数字类型
- 布尔类型
- 字符类型
- 类型转换
- 双等比较是什么
- java -- 运算符
- 算数运算符
- 字符串拼接
- 关系/比较运算符
- 自增减运算符
- 逻辑运算符
- 三目运算
- 赋值运算符
- 移位运算符
- 位运算符
- 运算符优先级
- java -- 流程控制语句
- if /else if /if -- 判断
- switch case分支结构
- for -- 循环
- 用双重for循环
- while -- 循环
- do while -- 循环
- 案例练习
- java -- 数组
- 数组的存储
- 数组的增删改查
- 数组的特点
- 数组案例
- 二维数组
- 数组的工具方法
- java -- 方法
- java -- 方法的重载
- java -- 方法的调用流程
- java -- 类方法传参注意事项
- java -- 方法练习案例
- 对比 return break continue
- for each循环
- java -- 基础练习
- java -- 面向对象
- java -- 创建类和对象
- java -- 访问控制符
- java -- 类成员方法
- java -- 构造方法
- java -- this
- java -- 封装
- java -- 对象内存图
- java -- 创建对象案例
- java -- static
- java -- 继承
- super -- 关键字
- java -- 构造块和静态代码块
- java -- 重写
- java -- final
- java -- 多态
- java -- 抽象类
- java -- 接口
- 引用类型数据转换
- 综合案例
- java -- 内部类
- java -- 回调模式
- java -- 枚举类型
- java -- switch 使用枚举
- java -- 枚举方法使用
- java -- 枚举类实现接口
- java -- javaBean
- java -- package 包
- java -- import
- java -- 递归练习
- java -- 设计模式
- 单例模式
- java -- 注解
- java -- 元注解
- Java -- 核心类库
- java -- 处理字符串
- Java -- String
- String -- 常用方法
- String -- 正则
- Java -- StringBuilder 和 StringBuffer
- 知识点
- Java -- StringJoiner 字符串拼接
- 练习题
- 字符串的总结
- Java -- 包装类
- Integer
- Double
- Boolean
- Character
- java -- 集合类
- java -- util.Collection
- Iterator接口
- java -- util.List
- java -- ArrayList
- java -- util.Queue
- java -- util.Set
- java -- util.Map
- java -- util.Collections
- Java -- Math
- Java -- java.lang
- Java -- Object
- Java -- 获取当前时间戳
- Java -- 异常
- Java -- java.util
- java -- Date
- java -- Calender
- Java -- java.text
- Java -- SimpleDateFormat
- Java -- java.time
- Java -- java.io
- java -- io.File
- java -- 泛型
- IDEA -- 用法