【Java基础06】ArrayList

文章目录

1.ArrayList
- [1.1 集合的基本使用](#1.1 集合的基本使用)
- [1.2 集合的创建和成员方法](#1.2 集合的创建和成员方法)
- [1.3 练习一：集合的遍历](#1.3 练习一：集合的遍历)
- - 基本数据类型对应的包装类
- [1.4 练习二：使用集合存储并遍历学生对象](#1.4 练习二：使用集合存储并遍历学生对象)
- [1.4 练习三：添加用户对象并判断是否存在](#1.4 练习三：添加用户对象并判断是否存在)
- - 写方法要思考的步骤
- [1.5 练习四：添加手机对象并返回要求的数据](#1.5 练习四：添加手机对象并返回要求的数据)
- - 技巧：如果要返回多个数据，可以把这些数据先放进一个容器当中，再把容器返回。如集合，数组。
[2 综合练习1：学生管理系统](#2 综合练习1：学生管理系统)
[2 综合练习2：学生管理系统升级版](#2 综合练习2：学生管理系统升级版)

本文部分参考本篇文章

1.ArrayList

1.1 集合的基本使用

集合有很多，如下图所示，本节所介绍的是其中一种：ArrayList

1.2 集合的创建和成员方法

成员方法：可以按照增删改查去记忆

java 复制代码

package ArrayList;

import java.util.ArrayList;

public class ArrayListDemo1 {
    public static void main(String[] args) {
        //1.创建集合的对象
        //泛型:限定集合中存储数据的类型。也就是那个<>，需要在类名后面加上<>表示数据类型

        //ArrayList<String> list = new ArrayList<String>();
        //JDK7
        ArrayList<String> list = new ArrayList<>();
        //此时我们创建的是ArrayList的对象，而ArrayList是java已经写好的一一个类
        //这个类在底层做了一些处理
        //Point! 打印对象不是地址值，而是集合中存储数据内容
        //Point! 在展示的时候会拿[]把所有的数据进行包装，逗号空格作为分隔

        System.out.println(list);

        //2.集合的成员方法
        //2.1添加元素
        //2.1.1末尾添加
         boolean result = list.add("A"); //会有返回值，但一般不用管，默认是ture，只需要使用添加功能就行
         System.out.println(result);
         System.out.println(list);
         list.add("A");
         list.add("B");
         list.add("C");
         System.out.println(list);

         //2.1.2 给定位置插入
        list.add(1,"A"); //在索引 1 的位置插入 "A"，原来这个位置及后面的元素会向后移动一位。

         //2.2 删除元素
         //2.2.1 根据元素值删除
         list.remove("B");//也有boolean返回值，删除成功返回true，失败返回false（要删除的元素不存在）
         System.out.println(list);
         boolean result2 = list.remove("D");
         System.out.println(result2);
         System.out.println(list);

         //2.2.2 根据索引删除
         //会返回被删除的元素
         String str = list.remove(0);
         System.out.println(str);
         System.out.println(list);

         //2.3 修改元素
         //会返回被覆盖的元素（原来的旧值）
        String str1 = list.set(0,"aaa");
        System.out.println(str1);
        System.out.println(list);

        //2.4 查询元素
        //2.4.1 根据索引查询
        //会返回查询到的元素
        String str2 = list.get(0);
        System.out.println(str2);

        //2.4.2 获取集合的长度 + 遍历
        for (int i = 0; i < list.size(); i++) { //list.fori即可得到
            String str3 = list.get(i);
            System.out.println(str3);
        }
    }
}

1.3 练习一：集合的遍历

定义一个集合,添加字符串，并进行遍历遍历格式参照: [元素1, 元素2,元素3]。

java 复制代码

package ArrayList;

import java.util.ArrayList;
import java.util.StringJoiner;

public class ArrayListTest01 {
    public static void main(String[] args) {
        //定义一个集合,添加字符串，并进行遍历 遍历格式参照: [元素1,元素2,元素3]。
        ArrayList<String> list = new ArrayList<>();
        list.add("A");
        list.add("B");
        list.add("C");
        list.add("D");
        list.add(1,"E"); //在索引 1 的位置插入 "E"，原来这个位置及后面的元素会向后移动一位。
        System.out.println(list);

        //方法一：使用sj（因为有开头结尾和间隔符进行联想）
        StringJoiner sj = new StringJoiner(",","[","]");
        //list.forEach(sj::add); //简略版本
        for (int i = 0; i < list.size(); i++) {
            sj.add(list.get(i));
        }
        System.out.println(sj.toString());


        System.out.print("["); //注意这里是得是print，不然会换行！！！
        for (int i = 0; i < list.size(); i++) {
            if(i==list.size()-1){
                System.out.print(list.get(i));
            } else{
                System.out.print(list.get(i) + ",");
            }
        }
        System.out.println("]");

        //注意，如果是添加数字，要变成对应包装类
        ArrayList<Integer> list2 = new ArrayList<>(); //注意不是int，是Integer
        //jdk5以后int Integer之间是可以互相转化的
        list2.add(1);
        list2.add(2);
        list2.add(3);
        System.out.println(list2);

        ArrayList<Character> list3 = new ArrayList<>();
        list3.add('A');
        list3.add('B');
        list3.add('C');
        System.out.println(list3);

    }
}

基本数据类型对应的包装类

集合中如果要添加基本数据类型，需要变成其对应的包装类

1.4 练习二：使用集合存储并遍历学生对象

需求：
定义一个集合，添加一些学生对象，并进行遍历
学生类的属性为：姓名，年龄。
要求：
对象的数据来自键盘录入

java 复制代码

package ArrayList;

import java.util.ArrayList;
import java.util.Scanner;

public class ArrayListTest02 {
    public static void main(String[] args) {
        /*需求：
        定义一个集合，添加一些学生对象，并进行遍历
        学生类的属性为：姓名，年龄。
        要求：
        对象的数据来自键盘录入*/

        //1.创建集合
        ArrayList<ArrayTest02_Stu> list = new ArrayList<>();

        ////2.创建学生对象
        //ArrayTest02_Stu s1 = new ArrayTest02_Stu("zhangsan",23);
        //ArrayTest02_Stu s2 = new ArrayTest02_Stu("lisi",24);
        //ArrayTest02_Stu s3 = new ArrayTest02_Stu("wangwu",25);

        //2.键盘录入学生的信息
        Scanner scanner = new Scanner(System.in);
        for (int i = 0; i < 2; i++) {
            System.out.println("输入名字");
            //point 每次会创建新的string对象，因此不会是同一个地址
            //point 如果把创建对象放在外部，那么每次list.add都是同一个地址，会产生输出的都是最后一次输入的值的情况
            String name = scanner.next();
            System.out.println("输入年龄");
            int age = scanner.nextInt();
            list.add(new ArrayTest02_Stu(name, age));
        }

        //3.添加元素
        //list.add(s1);  //point! 注意添加的是这个对象所在的地址,所以每次添加必须得创建多个对象，不然只能把一个对象来回添加多次
        //list.add(s2);
        //list.add(s3);

        //4.遍历集合
        for (int i = 0; i < list.size(); i++) {
            ArrayTest02_Stu stu = list.get(i);
            //输出的时候需要get，不然我们自己定义的类没有特殊处理直接print是地址值
            //System.out.println(stu);
            System.out.println(stu.getName() + "," + stu.getAge());
        }

    }
}

循环中注意每次放置进列表的都必须是一个新对象
如果把创建对象放在外部，那么每次list.add都是同一个地址，会产生输出的都是最后一次输入的值的情况

1.4 练习三：添加用户对象并判断是否存在

本题重点就是查找的方法，可以设置boolean返回值,遍历查找是否相同。

java 复制代码

package ArrayList;

import java.util.ArrayList;
import java.util.Scanner;

public class ArrayListTest03 {
    public static void main(String[] args) {
        ArrayList<ArrayTest03_User> list = new ArrayList<>();
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < 3; i++) {
            System.out.println("输入第"+(i+1)+"个用户的id");
            int id = sc.nextInt();
            System.out.println("输入用户姓名");
            String name = sc.next();
            System.out.println("输入用户密码");
            String password = sc.next();
            list.add(new ArrayTest03_User(id, name, password));
        }
        //输入查找的id
        System.out.println("请输入需要查找的id");
        int sid = sc.nextInt();
        boolean result = search(list, sid);
        System.out.println(result);
    }

    //写函数需要考虑的内容
    //1.这个方法用来干嘛？
    //2.这个方法需要哪些内容才能完成？
    //3.调用处是否需要使用方法返回的结果？

    public static boolean search(ArrayList<ArrayTest03_User> list, int sid){ //point 注意这里要指定类型
        // point！不能直接查，因为不一定能查到，查不到的话直接报错，无法返回boolean值！
        //遍历比较合适
        for (int i = 0; i < list.size(); i++) {
            ArrayTest03_User user = list.get(i);
            int id = user.getId();
            if(id == sid){
                return true;
            }
        }
        return false;
    }
}

写方法要思考的步骤

复制代码

//写函数需要考虑的内容
//1.这个方法用来干嘛？
//2.这个方法需要哪些内容才能完成？
//3.调用处是否需要使用方法返回的结果？

1.5 练习四：添加手机对象并返回要求的数据

java 复制代码

package ArrayList;

import java.util.ArrayList;

public class ArrayListTest04 {
    public static void main(String[] args) {
        ArrayList<ArrayTest04_Phone> list = new ArrayList<>();

        ArrayTest04_Phone p1 = new ArrayTest04_Phone("小米",1000);
        list.add(p1);
        ArrayTest04_Phone p2 = new ArrayTest04_Phone("苹果",8000);
        list.add(p2);
        ArrayTest04_Phone p3 = new ArrayTest04_Phone("锤子",2000);
        list.add(p3);

        ArrayList<ArrayTest04_Phone> result_list = search(list);
        if (result_list != null) {
            for (int i = 0; i < result_list.size(); i++) {
                System.out.println("品牌为"+result_list.get(i).getBrand()+","+"价格为"+result_list.get(i).getPrice());
            }
        }else{
            System.out.println("没有低于3000的手机");
        }

    }

    //point 技巧：
    //如果要返回多个数据，可以把这些数据先放进一个容器当中，再把容器返回
    //如集合，数组
    public static ArrayList<ArrayTest04_Phone> search(ArrayList<ArrayTest04_Phone> list){
        ArrayList<ArrayTest04_Phone> slist = new ArrayList<>();

        for (int i = 0; i < list.size(); i++) {
            if( list.get(i).getPrice() <= 3000 ){
                slist.add(list.get(i));
            }
        }
        return slist;
    }
}

技巧：如果要返回多个数据，可以把这些数据先放进一个容器当中，再把容器返回。如集合，数组。

2 综合练习1：学生管理系统

案例需求

针对目前我们的所学内容，完成一个综合案例：学生管理系统。

该系统主要功能如下：

添加学生：通过键盘录入学生信息，添加到集合中

删除学生：通过键盘录入要删除学生的学号，将该学生对象从集合中删除

修改学生：通过键盘录入要修改学生的学号，将该学生对象其他信息进行修改

查看学生：将集合中的学生对象信息进行展示

退出系统：结束程序

学生类

java 复制代码

package StudentSystem;

public class Student {
    private String id;
    private String name;
    private int age;
    private String address;

    public Student() {
    }

    public Student(String id, String name, int age, String address) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.address = address;
    }

    public String getId() {
        return id;
    }

    public void setId(String 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 String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

StudentSystem

java 复制代码

package StudentSystem;

import java.util.ArrayList;
import java.util.Scanner;

public class StudentSystem {
    public static void main(String[] args) {
        ArrayList<Student> list = new ArrayList<>();
        Scanner sc = new Scanner(System.in);

        boolean flag = false;
        while(!flag) {  //可以用loop，flag，exit(0)表示退出
            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.println("请输入你的选择：");

            int choice = sc.nextInt();

            switch (choice) {
                case 1 -> addStudent(list);  //箭头是新版，用冒号的话得另外写break
                case 2 -> deleteStudent(list);
                case 3 -> updateStudent(list);
                case 4 -> queryStudent(list);
                case 5 -> {
                    System.out.println("退出");
                    flag = true;
                }
                default -> System.out.println("没有这个选项");
            }
        }

    }

    public static void addStudent(ArrayList<Student> list) {
        System.out.println("进入添加学生板块");
        Scanner sc = new Scanner(System.in);

        System.out.println("请输入学生id");
        String id = sc.next();
        //while (true) { //point 这段整复杂了，还没考虑到二次检查
        //    boolean containId = contains(list, id);
        //    if (containId) {
        //        System.out.println("已经存在同样的ID，请换一个");
        //    } else{
        //        System.out.println("ID有效");
        //        break;
        //    }
        //    System.out.println("请输入新的id");
        //    id = sc.next(); //point 在循环外部声明的，不会随着循环结束消失
        //}

        //我的写法
        boolean containId = contains(list, id);
        while (containId) {
            System.out.println("已经存在同样的ID，请换一个");
            System.out.println("请输入新的id");
            id = sc.next();
            containId = contains(list, id);
        }
        System.out.println("ID有效");

        //视频的写法是先定义一个null的id，然后在while中输入，用if判断，满足条件可以break

        System.out.println("请输入姓名");
        String name = sc.next();

        System.out.println("请输入年龄");
        int age = sc.nextInt();

        System.out.println("请输入地址");
        String address = sc.next();

        list.add(new Student(id, name, age, address)); //也可以拆开用set

        System.out.println("学生信息添加成功");
    }

    public static void deleteStudent(ArrayList<Student> list) {
        System.out.println("进入删除学生板块");
        Scanner sc = new Scanner(System.in);

        System.out.println("请输入要删除的id");
        String id = sc.next();
        //检查id是否存在
        //point 可以直接看gexIndex是否大于0
        boolean containId = contains(list, id);
        if (containId) {
            System.out.println("存在该id");
            //ArrayList通过ID获取idx的部分得自己写
            int idx = getIndex(list, id);
            list.remove(idx);
            System.out.println("删除成功");
        }else{
            System.out.println("不存在该id");
            return;
        }
    }

    public static void updateStudent(ArrayList<Student> list) {
        System.out.println("进入修改学生板块");
        Scanner sc = new Scanner(System.in);

        System.out.println("请输入要修改的id");
        String id = sc.next();

        int idx = getIndex(list, id);
        if (idx != -1) {
            System.out.println("请输入要修改的学生姓名");
            String newName = sc.next();
            System.out.println("请输入要修改的学生age");
            int newAge = sc.nextInt();
            System.out.println("请输入要修改的学生地址");
            String newAddress = sc.next();
            list.set(idx, new Student(id, newName, newAge, newAddress));
            System.out.println("修改成功");
        }else{
            System.out.println("不存在该id");
        }


    }

    public static void queryStudent(ArrayList<Student> list) {
        System.out.println("进入查询学生板块");
        if(list.isEmpty()) {
            System.out.println("无学生信息");
            return;  //注意得有这个
        }
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入要查询的学生的id");
        String id = sc.next();

        //最好是遍历，不过如果都是按照顺序来的话应该也可以进行一个越界判断然后输出
        for (int i = 0; i < list.size(); i++) {
            if(id.equals(list.get(i).getId())) {
                Student querystu = list.get(i);
                System.out.println("id\t姓名\t年龄\t住址");
                System.out.println(querystu.getId() + "\t" + querystu.getName() + "\t" + querystu.getAge() + "\t" + querystu.getAddress());
                return;
            }
        }
        System.out.println("没有要查询的学生信息");
        //return; point 如果是void 不需要最后的return
    }

    public static boolean contains(ArrayList<Student> list, String id) {
        //循环遍历得到每一个学生对象
        //拿到学生对象后，获取id进行判断
        for (int i = 0; i < list.size(); i++) {
            if(list.get(i).getId().equals(id)) {
                return true;
            }
        }
        return false;
    }//这块可以直接调用下面的 getIndex>=0就是true

    //对应输入id的索引
    public static int getIndex(ArrayList<Student> list, String id) {
        int idx = 0;
        for (int i = 0; i < list.size(); i++) {
            Student stu = list.get(i);
            String stuId = stu.getId();
            //查询到的id和要删除id进行比较
            if(stuId.equals(id)) {
                idx = i;
                return idx;
            }
        }
        return -1;  //point必须得在这写个返回，就-1就行
    }

}

注意点（循环检验，查找满足某条件的对象是否存在）

注意：getIndex可以替代contains，有就是对应索引，没有就是-1
必须得遍历结束后再return false，不能for不满足直接returnfalse
经典结构：while(true){ if(满足条件)break; else{continue;}} 这样可以循环，直至满足条件

也可以用flag，loop，exit(0)终止循环

2 综合练习2：学生管理系统升级版

加入了登录，注册和忘记密码三个板块

User类

java 复制代码

package StudentSystem;

public class User {
    private String name;
    private String password;
    private String personID;
    private String phoneNumber;

    public User() {
    }

    public User(String name, String password, String personID, String phoneNumber) {
        this.name = name;
        this.password = password;
        this.personID = personID;
        this.phoneNumber = phoneNumber;
    }

    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 getPhoneNumber() {
        return phoneNumber;
    }

    public void setPhoneNumber(String phoneNumber) {
        this.phoneNumber = phoneNumber;
    }
}

App

java 复制代码

package StudentSystem;

import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;

public class App {
    public static void main(String[] args) {
        ArrayList<User> list = new ArrayList<>();
        Scanner sc = new Scanner(System.in);

        boolean flag = true;
        while (flag) {
            System.out.println("------欢迎来到学生管理系统------");
            System.out.println("1.登录");
            System.out.println("2.注册");
            System.out.println("3.忘记密码");
            System.out.println("4.退出");
            System.out.println("请输入你的选择：");
            int choice = sc.nextInt();

            switch (choice) {
                case 1 -> logIn(list);
                case 2 -> register(list);
                case 3 -> forgetPassword(list);
                case 4 -> {
                    System.out.println("退出系统，再见");
                    flag = false;
                    //return;  //如果程序不是循环运行的，在这return一下就行
                }
                default -> System.out.println("没有这个选项");
            }
        }

    }

    public static void logIn(ArrayList<User> list){
        System.out.println("进入登录板块");
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < 3; i++ ) {
            //1.键盘录入用户名
            System.out.println("请输入用户名");
            String username = sc.next();
            //检测用户名是否存在
            boolean check = contains(list, username);
            if (!check) {
                System.out.println("用户名"+username+"不存在，请先注册");
                return;
            }

            //2.键盘录入密码
            System.out.println("请输入密码");
            String password = sc.next();

            //3.键盘录入验证码
            while (true) {
                String rightcode = getCode();
                System.out.println("验证码为" + rightcode);
                System.out.println("请输入验证码");
                String code = sc.next();
                if(code.equalsIgnoreCase(rightcode)){ //point 忽略大小写
                    System.out.println("验证码正确");
                    break;
                }else{
                    System.out.println("验证码错误");
                    continue;
                }
            }

            //4.验证用户名和密码是否正确
            //检测是否在集合中
            //point 封装思想的应用
            //point 把一些零散的数据，封装成一个对象
            User userInfo = new User(username,password,null,null);
            boolean checkcheckUserInfo = checkUserInfo(list,userInfo);
            if (checkcheckUserInfo) {
                System.out.println("登录成功，可以使用");
                break;
            }else{
                System.out.println("登录失败，用户名或者密码错误");
                if(i == 2){
                    System.out.println("当前账号"+username+"被锁定");
                    return;
                }else{
                    System.out.println("登录失败，用户名或者密码错误,还剩下"+(2-i)+"次机会");
                }
            }
        }

    }

    private static boolean checkUserInfo(ArrayList<User> list, User userInfo) {
        for (int i = 0; i < list.size(); i++) {
            User user = list.get(i);
            if(user.getName().equals(userInfo.getName()) && user.getPassword().equals(userInfo.getPassword())){
                return true;
            }
        }
        return false;
    }

    public static void register(ArrayList<User> list){
        System.out.println("进入注册板块");
        //在外部声明变量
        String username= null; //point 初始化避免报错
        String password= null;
        String personID= null;
        String phoneNumber= null;
        //添加用户信息到集合中

        //1.键盘录入添加用户名以及判断限制
        Scanner sc = new Scanner(System.in);
        boolean flag = true;
        while (flag) {
            System.out.println("请输入用户名");
            username = sc.next();
            //point 先验证格式是否正确，再验证是否唯一
            //1.1 用户名长度3-15位之间
            //1.2 不能是纯数字，需要是数字加字母
            //1.3 用户名唯一
            boolean checkUsername = checkUsername(username);
            //到这里判断用户名格式是否正确，接着才能判断是否唯一
            if(!checkUsername){
                System.out.println("格式不正确，请重新输入");
                continue; //point 善于使用continue！！
            }
            //走到这一步，因为有continue，已经保证了格式正确
            System.out.println("格式正确，验证id是否唯一");
            boolean flag2 = contains(list, username);
            if(flag2){
                System.out.println("用户名重复，请重新输入");
                continue;
            } else{
                System.out.println("id唯一，用户名"+username+"可用");
                flag = false;   //或者外层设为true，这里直接break
            }
        }

        System.out.println("用户名设置成功，请输入密码");
        //键盘录入添加密码以及判断限制
        while (true) {
            password = sc.next();
            System.out.println("请再次输入密码");
            String againPassword = sc.next();
            if(password.equals(againPassword)){
                System.out.println("两次密码一致");
                break;
            }else{
                System.out.println("两次密码不一致,请重新输入密码");
                continue;
            }
        }

        System.out.println("密码设置成功，请输入身份证号码");
        //键盘录入身份证号码以及判断限制
        //长度为18位
        //不能0开头
        //前17位必须是数字
        //最后一位可以是数字，也可以是大写X或者小写x
        while (true) {
            System.out.println("请输入身份证号码");
            personID = sc.next();
            boolean flag2 = checkPersonID(personID);
            if(!flag2){
                continue;
            }else{
                System.out.println("身份证号码设置成功");
                break;
            }
        }

        System.out.println("身份证号码设置成功，请输入手机号");
        //键盘录入手机以及判断限制
        //长度为11位
        //不能0开头
        //必须是数字
        while (true) {
            System.out.println("请输入手机号");
            phoneNumber = sc.next();
            boolean flag3 = checkPhoneNumber(phoneNumber);
            if(flag3){
                System.out.println("手机号设置成功");
                break;
            }
        }

        //把输入正确的内容放到用户对象中
        list.add(new User(username,password,personID,phoneNumber));
        System.out.println("注册成功");
        printList(list);
        
    }

    public static void forgetPassword(ArrayList<User> list){
        System.out.println("进入忘记密码板块");

        Scanner sc = new Scanner(System.in);
        //1.键盘录入用户名
        System.out.println("请输入用户名");
        String username = sc.next();
        boolean checkUsername = contains(list,username);
        if(checkUsername){
            System.out.println("存在此用户");
        }else{
            System.out.println("用户名"+username+"不存在，请先注册");
            return;
        }

        //2.键盘录入身份证和手机号
        System.out.println("请输入身份证");
        String personID = sc.next();
        System.out.println("请输入手机号");
        String phoneNumber = sc.next();

        //验证身份证和手机号
        User checkUser = new User(username,null,personID,phoneNumber);

        int index = findIndex(list, checkUser.getName());
        User findUser = list.get(index);
        if(findUser.getPersonID().equalsIgnoreCase(checkUser.getPersonID()) && //point 可以Ingore，排除掉大小写X的影响
                findUser.getPhoneNumber().equals(checkUser.getPhoneNumber())){
            System.out.println("身份证或手机号验证正确");
        }else{
            System.out.println("身份证和手机号输入错误");
            return;
        }

        //已经验证了身份证和手机号，可以开始修改密码
        String newPassword = null;
        while (true) {
            System.out.println("请输入新密码");
            newPassword = sc.next();
            System.out.println("请再次输入新密码");
            String newPassword2 = sc.next();
            if(newPassword.equals(newPassword2)){
                System.out.println("两次密码一致，有效");
                break;
            }else{
                System.out.println("两次密码不一致，重新输入");
                continue;
            }
        }

        //修改密码
        list.get(index).setPassword(newPassword); //善于使用get方法
        System.out.println("密码修改成功");

    }


    private static int findIndex(ArrayList<User> list, String name) {
        for (int i = 0; i < list.size(); i++) {
            User user = list.get(i);
            if (user.getName().equals(name)) {
                return i;
            }
        }
        return -1;
    }

    private static void printList(ArrayList<User> list) {
        for (int i = 0; i < list.size(); i++) {
            User user = list.get(i);
            System.out.println(user.getName()+","+user.getPassword()+","
                    +user.getPersonID()+","+user.getPhoneNumber());
        }
    }

    private static boolean checkPhoneNumber(String phoneNumber) {
        //长度为11位
        if(phoneNumber.length() != 11){
            System.out.println("手机号不是11位，请重新输入");
            return false;
        }

        //不能0开头
        char firstNumber = phoneNumber.charAt(0);
        if(firstNumber == '0'){
            System.out.println("手机号不能为0开头，请重新输入");
            return false;
        }

        //必须是数字
        for (int i = 0; i < phoneNumber.length(); i++) {
            char ch = phoneNumber.charAt(i);
            if(!(ch >= '0' && ch <= '9')){
                System.out.println("手机号存在非数字，请重新输入");
                return false;
            }
        }
        return true;
    }

    private static boolean checkPersonID(String personID) {
        //长度为18位
        if(personID.length() != 18){
            System.out.println("身份证不是18位，请重新输入");
            return false;
        } else{
            System.out.println("身份证满足18位，继续检验");
        }

        //不能0开头
        char firstChar = personID.charAt(0);
        if(firstChar == '0'){
            System.out.println("身份证首位为0，请重新输入");
            return false;
        }else{
            System.out.println("身份证首位满足不为0，继续检验");
        }

        //前17位必须是数字
        for (int i = 0; i < personID.length() - 1 ; i++) { //前17位，长度-1就行
            char ch = personID.charAt(i);
            if(!(ch <= '9' && ch >= '0')){
                System.out.println("前17位存在非数字，请重新输入");
                return false;
            }
        }

        //最后一位可以是数字，也可以是大写X或者小写x
        char lastChar = personID.charAt(personID.length() - 1);
        if(!(lastChar <= '9' && lastChar >= '0') || (lastChar == 'X') || (lastChar == 'x')){
            System.out.println("最后一位输入有问题，请重新输入");
            return false;
        }else{
            return true;
        }
    }

    public static boolean checkUsername(String username){
        //1.1 用户名长度3-15位之间
        //if (username.length() < 3 || username.length() > 15) //point 这样写调用两次有点复杂
        int len = username.length(); //多写一步可读性高，调用一次效率提升
        if(len < 3 || len > 15){
            return false;
        }

        //1.2 不能是纯数字，需要是数字加字母
        //循环遍历
        int cnt = 0;
        for (int i = 0; i < username.length(); i++) {
            char ch = username.charAt(i);
            if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')) {
                cnt++;
                break; //有一个字母就不用继续遍历了
            }
        }
        //if(cnt == 0){
        //    return false;
        //}
        return cnt > 0;
    }

    public static boolean contains(ArrayList<User> list, String username){
        for (int i = 0; i < list.size(); i++) {
            User u = list.get(i);
            if (u.getName().equals(username)) {
                return true;
            }
        }
        //必须得遍历结束后再return false
        return false; //list为空默认可以
    }

    public static String getCode(){
        //生成验证码
        //1.创建一个包含所有字母的集合或者stringbuilder
        ArrayList<Character> list = new ArrayList<>();
        for (int i = 0; i < 26; i++) {
            list.add((char) ('a' + i));
            list.add((char) ('A' + i));
        }

        //挑选随机字母//point 可以随机生成五个，其中一个用数字覆盖
        StringBuilder sb = new StringBuilder();
        Random r = new Random();
        for (int i = 0; i < 4; i++) {
            int index = r.nextInt(list.size());
            sb.append(list.get(index));
        }

        //挑选随机数字
        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);
    }
}

封装思想

把一些零散的数据，封装成一个对象，传入或者传出，会更加高效

多写一步可读性高

java 复制代码

if (username.length() < 3 || username.length() > 15) {...}//point 这样写调用两次有点复杂

//多写一步可读性高，调用一次效率提升
int len = username.length(); 
if(len < 3 || len > 15){...}

如何调整字符串中内容

1.substring，适用于已知移动到哪里

2.把字符串先变为一个字符数组，然后调整字符数组里面的数据，最后再把字符数组变为字符串

其他注意点

str.equalsIgnoreCase忽略大小写比较，验证码和身份证最后一位都可以用得到

整个方法内都要用到的变量不要在循环里声明+初始化（只在循环里初始化也会报错的其实），可以外部声明，初始化一个空值。