Java 常用API（String、ArrayList）

亦凉 2024-03-03 01:57 13阅读 0赞

**API（Application Programming Interface，应用程序编程接口）**

Java写好的程序（功能），我们可以直接调用。

Oracle也为Java提供的这些功能代码提供了相应的API文档（使用说明书）。

![c043136fa8234464a3e713713a8f6634.png][]

### 一、String类 ###

#### 1、String类概述 ####

接下来我们学习String这个类，也就是学对字符串进行处理。为什么要学习字符串处理呢？因为在开发中对于字符串的处理还是非常常见的。

比如：在用户登录时，用户输入的用户名和密码送到后台，需要和正确的用户名和密码进行校验，这就需要用到String类提供的比较功能。

![aee29273fb8b42d89324fd83645224c1.png][]

再比如：大家在打游戏时，有些人可能不太文明说了一些脏话，后台检测到你输入的是脏话，就会用\*\*\*把脏话屏蔽掉。这也需要用到String类提供的替换功能。

![23ba4c9a837049f197263cb3cb20af52.png][]

Java为了方便我们处理字符串，所以给我们提供了一个String类来代表字符串，这个类就是`java.lang`包下。

按照面向对象的编程思想，对于字符串的操作，只需要创建字符串对象，用字符串对象封装字符串数据，然后调用String类的方法就可以了。

1.  创建对象
2.  封装字符串数据
3.  调String的方法

#### 2、String创建对象 ####

接下来我们打开String类的API，看一下String类的对象如何创建。如下图所示：

![9e136bc224de4a2eaa2ed589340a57cc.png][]

String类的API中，有这么一句话：“Java程序中的所有字符串字面值（如"abc"）都是字符串的实例实现”。这里所说的实例实现，其实指的就是字符串对象。

意思就是：**所有Java的字符串字面值，都是字符串对象。**

*  所以创建String对象的第一种方式就有了

> String s1 = "abc"; // 这里"abc"就是一个字符串对象，用s1变量接收
> 
> String s2 = "程序员"; // 这里的“程序员”也是一个字符串对象，用s2变量接收

*  创建String对象还有第二种方式，就是利用String类的构造方法创建String类的对象。

![88738d01167c488689dc1f037f8d3528.png][]

下面我们演示通过String类的构造方法，创建String类的对象：

/**
     * 目标：掌握创建String对象，并封装要处理的字符串的两种方式。
     */
    public class StringDemo {
        public static void main(String[] args) {
            // 方式一：直接使用双引号得到字符串对象
            String name = "我爱你中国";
            System.out.println(name);
    
            // 方式二：
            // 1、public String(): 创建一个空白字符串对象，不含有任何内容 （几乎不用）
            String s1 = new String(); // s1 = ""
            System.out.println(s1);
    
            // 2、public String(String): 根据传入的字符串内容，来创建字符串对象（几乎不用）
            String s2 = new String("我是中国人");
            System.out.println(s2);
    
            // 3、public String(char[] c): 根据字符数组的内容，来创建字符串对象
            char[] chars = {'a' , 'b' , '中', '国'};
            String s3 = new String(chars);
            System.out.println(s3);
    
            // 4、public String(byte[] b):  根据字节数组的内容，来创建字符串对象
            byte[] bytes = {97, 98, 99, 65, 66, 67};
            String s4 = new String(bytes);
            System.out.println(s4);
    
            System.out.println("---------------------------------------");
            String ss1 = "abc";
            String ss2 = "abc";
            System.out.println(ss1 == ss2);
    
            char[] chars1 = {'a' , 'b' , 'c'};
            String ss3 = new String(chars1);
            String ss4 = new String(chars1);
            System.out.println(ss3 == ss4);
        }
    }

#### 3、String类的常用方法 ####

##### 3.1 字符串内容比较 #####

推荐使用String提供的 "equals" 比较：只关心内容一样即可。

![a6246e0679524c09b8bfe81d6623fb2b.png][]

public class StringMethodDemo1 {
        /*
    
            String类中用于比较的方法 :
    
                    public boolean equals(Object anObject) 将此字符串与指定的对象比较
    
                    public boolean equalsIgnoreCase(String anotherString) 将此 String 与另一个 String 比较，不考虑大小写
         */
        public static void main(String[] args) {
    
            String s1 = "abc";
            String s2 = new String("abc");
    
            System.out.println(s1 == s2);               // false
            System.out.println(s1.equals(s2));          // true
    
            System.out.println("---------------------");
    
            String ss1 = "abc";
            String ss2 = "ABC";
    
            System.out.println(ss1.equals(ss2));                // false
            System.out.println(ss1.equalsIgnoreCase(ss2));      // true
        }
    }

##### 3.2 String字符串的遍历 #####

![831c5904a1824a019eade40201f09811.png][]

public class StringMethodDemo2 {
        /*
            String类用于遍历的方法:
    
                public char[] toCharArray() 将此字符串转换为一个新的字符数组
    
                public char charAt(int index) 返回指定索引处的 char 值
    
                public int length() 返回此字符串的长度
         */
        public static void main(String[] args) {
    
        }
    
        /**
         * 字符串遍历的第二种方式
         */
        private static void print2() {
            String s = "itheima";
    
            for (int i = 0; i < s.length(); i++) {
                // i = 0 1 2 3 4 5 6
                char c = s.charAt(i);
                System.out.println(c);
            }
        }
    
        /**
         * 字符串的第一种遍历方式
         */
        private static void print1() {
            String s = "itheima";
    
            char[] chars = s.toCharArray();
    
            for (int i = 0; i < chars.length; i++) {
                System.out.println(chars[i]);
            }
        }
    }

##### 3.3 String字符串的截取 #####

![25f20a3abeee4898a56cc79465248e6e.png][]

public class StringMethodDemo3 {
        /*
            String类的截取方法 :
    
                public String substring(int beginIndex) :  根据传入的索引开始做截取, 截取到字符串的末尾
                public String substring(int beginIndex, int endIndex) :  根据传入的开始和结束索引, 对字符串做截取
                                                                            - 包含头, 不包含尾
    
                注意: 截取出来的内容, 是作为新的字符串返回, 别忘记找变量接收
         */
        public static void main(String[] args) {
    
            String s = "itheima";
    
            String result = s.substring(0, 2);
    
            System.out.println(result);
    
        }
    
        private static void method() {
            String s = "itheima";
    
            String result = s.substring(2);
    
            System.out.println(result);
        }
    }

##### 3.4 替换 #####

注意点：返回值才是替换之后的结果。

![cb058a40a30a40eca0ab1cdf71833da7.png][]

public class StringMethodDemo4 {
        /*
            String类的替换方法 :
    
                public String replace(CharSequence target, CharSequence replacement)  :
    
                                    参数1 : 旧值
                                    参数2 : 新值
         */
        public static void main(String[] args) {
    
            String s = "itheima";
    
            String result = s.replace("heima", "baima");
    
            System.out.println(result);
    
        }
    }

##### 3.5 分割 #####

![61c447f6adae4464b708ce3a3c26d5c8.png][]

public class StringMethodDemo5 {
        /*
            String类的切割方法 :
    
                public String[] split(String regex) : 根据传入的字符串作为规则, 切割当前字符串
    
    
            建议: 先正常指定切割规则, 后来发现没有得到自己要的效果, 就可以尝试在规则前面, 加入 \\
         */
        public static void main(String[] args) {
    
            String s = "192+168+1+1";
    
            String[] sArr = s.split("\\+");
    
            for (int i = 0; i < sArr.length; i++) {
                System.out.println(sArr[i]);
            }
    
        }
    }

#### 4、String的注意事项 ####

![2fa59f363e1b4070a377b5ac78085bb1.png][]

*  **注意事项1：String类的对象是不可变的对象**

我们先看一段代码，分析这段代码的结果

![4dd2f5c2c53742c0b559d34af9f55f12.png][]

以上代码中，先定义了一个String变量 name第一次赋值为"黑马"然后对name变量记录的字符串进行两次拼接，第一次拼接"程序员"，第二次拼接"播妞"；我们发现得到的结果是：黑马程序员播妞

这里问题就来了，你不是是说：**String类的对象是不可变的字符串对象吗？**我看name的值变了呀！！！

下面就来解释一下，String是不可变对象到底是什么含义。

需要注意的是：只要是以`“”`方式写出的字符串对象，会在堆内存中的**字符串常量池**中存储。

执行第一句话时，会在堆内存的常量池中，创建一个字符串对象"黑马"，然后把"黑马"的地址赋值给String name

![fcfb1e7fe6834b0d83518d5572a380e9.png][]

当执行第二句话时，又会再堆内存的常量池中创建一个字符串"程序员"，和"黑马"拼接，拼接之后还会产生一个新的字符串对象"黑马程序员"，然后将新产生的"黑马程序员"对象的地址赋值给String

name变量。

![1986d678755e491aa0207fdb4313dcb7.png][]

此时你会发现，之前创建的字符串对象"黑马"内容确实是没有改变的。所以说String的对象是不可变的。

*  **注意事项2：字符串字面量和new出来字符串的区别**

1.  只要是以"**...**"方式写出的字符串对象，会存储到字符串常量池，且相同内容的字符串只存储一份。如下图一所示：
2.  但通过new方式创建字符串对象，每new一次都会产生一个新的对象放在堆内存中。如下图二所示：

![71b0e46cfbd04b47bfba05d3995eeefa.png][]

![a9ebf92550d040c99f9a0143b7a97186.png][]

> 总结：
> 
> 字符串的注意事项
> 
> 1. String是不可变字符串对象  
> 2. 只要是以“...”方式写出的字符串对象，会存储到字符串常量池，且相同内容的字符串只存储一份；  
> 3. 但通过new方式创建字符串对象，每new一次都会产生一个新的对象放在堆内存中。

#### 5、String案例 ####

**案例1：String类开发验证码功能**

> **需求：**
> 
> 随机产生一个5位的验证码，每位可能是数字、大写字母、小写字母。
> 
> **分析：**
> 
> 1.定义一个String类型的变量存储a~z，A~Z，0~9的全部字符。
> 
> 2.循环5次，随机一个范围内的索引，获取对应字符连起来即可。

/**
        练习题：使用String完成随机生成5位的验证码。
     */
    public class StringExec1 {
        public static void main(String[] args) {
            // 1、定义可能出现的字符信息
            String datas = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
            
            // 2、循环5次，每次生成一个随机的索引，提取对应的字符连接起来即可
            String code = "";
            Random r = new Random();
            for (int i = 0; i < 5; i++) {
                // 随机一个索引
                int index = r.nextInt(datas.length());
                char c = datas.charAt(index);
                code += c;
            }
    
            // 3、输出字符串变量即可
            System.out.println(code);
        }
    }

**案例2：模拟用户登录功能**

> **需求：**
> 
> 模拟用户登录功能，最多只给三次机会。
> 
> **分析：**
> 
> 1.系统后台定义好正确的登录名称、密码。
> 
> 2.使用循环控制三次，让用户输入正确的登录名和密码，判断是否登录成功，
> 
> 登录成功则不再进行登录，登录失败给出提示，并让用户继续登录。

/**
        练习题：模拟用户登录
     */
    public class StringExec2 {
        public static void main(String[] args) {
            // 1、定义正确的登录名称和密码
            String okLoginName = "admin";
            String okPassword = "itheima";
    
            // 2、定义一个循环，循环3次，让用户登录
            Scanner sc = new Scanner(System.in);
            for (int i = 1; i <= 3; i++) {
                System.out.println("请您输入登录名称：");
                String loginName = sc.next();
                System.out.println("请您输入登录密码：");
                String password = sc.next();
    
                // 3、判断登录是否成功！
                if(okLoginName.equals(loginName)){
                    // 4、判断密码是否正确
                    if(okPassword.equals(password)){
                        System.out.println("登录成功！欢迎进入系统随意浏览~~~~");
                        break;
                    }else {
                        // 密码错误了
                        System.out.println("您的密码不正确！您还剩余" + (3 - i) +"次机会登录！");
                    }
                }else {
                    System.out.println("您的登录名称不正确！您还剩余" + (3 - i) +"次机会登录！");
                }
    
            }
        }
    }

**案例3：手机号码屏蔽**

> **需求：**
> 
> 键盘录入一个手机号，将中间四位号码屏蔽，最终效果为：158\*\*\*\*7839。
> 
> **分析：**
> 
> 1.键盘录入一个字符串。
> 
> 2.调用字符串对象的截取API，截取字符串前三位，后四位。
> 
> 将前三位连接 " \*\*\*\* " ，然后继续连接后四位，输出最终结果即可。

/**
        练习题：手机号码屏蔽
     */
    public class StringExec8 {
        public static void main(String[] args) {
            // 1、键盘录入一个手机号码
            Scanner sc = new Scanner(System.in);
            System.out.println("请您输入您的手机号码：");
            String tel = sc.next();
    
            // 2、截取号码的前三位，后四位    18665666520
            String before = tel.substring(0, 3); // 0  1  2
            String after = tel.substring(7);  // 从索引7开始截取到手机号码的末尾
    
            String s = before + "****" + after;
            System.out.println(s);
        }
    }

### 二、ArrayList ###

#### 1、ArrayList快速入门 ####

ArrayList表示一种集合，它是一个容器，用来装数据的，类似于数组。那有了数组，为什么要有集合呢？

因为数组一旦创建大小不变，比如创建一个长度为3的数组，就只能存储3个元素，想要存储第4个元素就不行。而集合是大小可变的，想要存储几个元素就存储几个元素，在实际工作中用得更多。

![cdc0dd251ad94ac9bf28f197fe39a64a.png][]

> 集合该怎么学呢？
> 
> 1.  会提供创建容器对象的方式，即创建集合对象；
> 2.  能够调用集合提供的方法对容器中的数据进行增删改查；
> 3.  知道集合的其他特点。

#### 2、ArrayList集合的特点 ####

##### 2.1 数组的特点 #####

![caf63bbdb76e46d8b9893d04ba65ceca.png][]

数组定义完成并启动后，**类型确定、长度固定**。

问题：在个数不能确定，且要进行增删数据操作的时候，数组是不太合适的。

##### 2.2 集合的特点 #####

![09fc576920a84a23bd1a083f254d843e.png][]

集合的大小不固定，启动后可以动态变化，类型也可以选择不固定。

集合非常适合做元素个数不确定，且要进行增删操作的业务场景。

结合还提供了许多丰富、好用的功能，而数组的功能很单一。

##### 2.3 ArrayList长度可变原理 #####

![43e82fe941a74ffda4fb6262a2f98bc0.png][]

#### 3、ArrayList集合的常用方法 ####

##### 3.1 ArrayList集合 #####

ArrayList是集合中的一种，它支持索引。

##### 3.2 ArrayList集合的对象的创建方法 #####

![08d907e583b74a43b785d0b2cc5273be.png][]

##### 3.3 ArrayList集合的添加元素的方法 #####

![5a452298fa084c49b6d64dce61b437f3.png][]

/**
     * 目标: 创建ArrayList对象，代表集合容器，往里面添加元素。
     */
    public class ArrayListDemo1 {
        public static void main(String[] args) {
            // 1、创建ArrayList集合的对象
            // ArrayList<String> list = new ArrayList<String>();
            // 从jdk1.7开始支持的
            ArrayList<String> list = new ArrayList<>();
    
            // 添加数据
            list.add("黑马");
            list.add("黑马");
            // list.add(23);
            // list.add(23.5);
            list.add("Java");
            System.out.println(list);
    
            // 2、往集合中的某个索引位置处添加一个数据
            list.add(1, "MySQL");
            System.out.println(list);
    
            // 3、根据索引获取集合中某个索引位置处的值
            String rs = list.get(1);
            System.out.println(rs);
    
            // 4、获取集合的大小(返回集合中存储的元素个数)
            System.out.println(list.size());
    
            // 5、根据索引删除集合中的某个元素值，会返回被删除的元素值给我们
            System.out.println(list.remove(1));
            System.out.println(list);
    
            // 6、直接删除某个元素值，删除成功会返回true，反之
            System.out.println(list.remove("Java"));
            System.out.println(list);
    
            list.add(1, "html");
            System.out.println(list);
    
            // 默认删除的是第一次出现的这个黑马的数据
            System.out.println(list.remove("黑马"));
            System.out.println(list);
    
            // 7、修改某个索引位置处的数据，修改后会返回原来的值给我们
            System.out.println(list.set(1, "黑马程序员"));
            System.out.println(list);
        }
    }

#### 4、ArrayList对于泛型的支持 ####

##### 4.1 泛型概述 #####

ArrayList<E>：其实就是一个泛型类，可以在编译阶段约束集合对象只能操作某种数据类型。

**举例：**

ArrayList<String>：此集合只能操作字符串类型的元素。

ArrayList<Integer>：此集合只能操作整数类型的元素。

**注意：泛型只能支持引用数据类型，不支持基本数据类型。**

public class ArrayListDemo1 {
        /*
            ArrayList集合的使用:
    
                细节: 创建String, StringBuilder, ArrayList类的对象, 打印对象名, 都没有看到地址值, 而是元素内容
    
                1. 构造方法 :
    
                        public ArrayList() : 创建一个空的集合容器
    
                2. 集合容器的创建细节 :
    
                        ArrayList list = new ArrayList();
                        现象: 可以添加任意类型数据
                        弊端: 数据不够严谨
    
    
                        ArrayList<String> list = new ArrayList<>();
    
                        <> : 泛型
                                    目前: 使用泛型, 可以对集合中存储的数据, 进行类型限制
                                    细节: 泛型中, 不允许编写基本数据类型
                                    问题: 那我要是想集合中, 存储 整数, 小数, 字符... 这些数据, 怎么办呢?
                                    解决: 使用基本数据类型, 所对应的包装类
    
                                                byte           Byte
                                                short          Short
                                                int            Integer    ***
                                                long           Long
                                                float          Float
                                                double         Double
                                                boolean        Boolean
                                                char           Character  ***
         */
        public static void main(String[] args) {
    
            // 步骤1: 创建一个集合容器, 内部存储 11.1 22.2 33.3
            ArrayList<Double> list1 = new ArrayList<>();
            list1.add(11.1);
            list1.add(22.2);
            list1.add(33.3);
    
            // 步骤2: 创建一个集合容器, 内部存储 张三, 李四, 王五
            ArrayList<String> list2 = new ArrayList<>();
            list2.add("张三");
            list2.add("李四");
            list2.add("王五");
    
            // 步骤3: 在控制台展示两个集合中的元素
            System.out.println(list1);
            System.out.println(list2);
    
    
        }
    }

#### 5、ArrayList常用方法、遍历 ####

**ArrayList集合常用方法**

![7b1344f7d8db4724b6771b0f9577ec2d.png][]

/**
        目标：掌握ArrayList集合的常用API
     */
    public class ArrayListDemo2 {
        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);
    
            // 2、public int size()：获取集合的大小（元素个数）
            System.out.println(list.size());
    
            // 3、完成集合的遍历
            for (int i = 0; i < list.size(); i++) {
                System.out.println(list.get(i));
            }
    
            // 4、public E remove(int index)：删除某个索引位置处的元素值,并返回被删除的元素值
            System.out.println(list); // [Java, Java, MySQL, MyBatis, HTML]
            String e2 = list.remove(2);
            System.out.println(e2);
            System.out.println(list);
    
            // 5、public boolean remove(Object o):直接删除元素值，删除成功返回true，删除失败返回false
            System.out.println(list.remove("MyBatis"));
            System.out.println(list);
    
            ArrayList<String> list1 = new ArrayList<>();
            list1.add("Java");
            list1.add("王宝强");
            list1.add("Java");
            list1.add("MySQL");
            System.out.println(list1);
            // 只会删除第一次出现的这个元素值，后面的不删除
            System.out.println(list1.remove("Java"));
            System.out.println(list1);
    
            // 6、public E set(int index,E element)：修改某个索引位置处的元素值。
            String e3 = list1.set(0 , "贾乃亮");
            System.out.println(e3);
            System.out.println(list1);
    
        }
    }

#### 6、ArrayList集合案例 ####

##### 6.1 案例1：遍历并删除元素 #####

> **需求：**
> 
> 某个班级的考试在系统上进行，成绩大致为：98，77，66，89，79，50，100
> 
> 现在需要先把成绩低于80分一下的数据去掉。
> 
> **分析：**
> 
> 1.定义ArrayList集合存储多名学员的成绩。
> 
> 2.遍历集合每个元素，如果元素低于80分，去掉它。

/**
       案例：从集合中遍历元素且删除。
     */
    public class ArrayListTest1 {
        public static void main(String[] args) {
            // 1、创建集合对象：存入学生成绩(98,77,66,89,79,50,100)
            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]
            // [98, 66, 89, 50, 100]
            //                   i
    
            // 1、遍历集合中的每个元素
    //        for (int i = 0; i < scores.size(); i++) {
    //            int score = scores.get(i);
    //            // 2、判断这个分数是否低于80分，如果低于则从集合中删除它
    //            if(score < 80){
    //                scores.remove(i);
    //            }
    //        }
    //        System.out.println(scores);
    
    
            // [98, 77, 66, 89, 79, 50, 100]
            // [98,  89, 100]
            //   i
    
            for (int i = scores.size() - 1; i >= 0 ; i--) {
                int score = scores.get(i);
                // 2、判断这个分数是否低于80分，如果低于则从集合中删除它
                if(score < 80){
                    scores.remove(i);
                }
            }
            System.out.println(scores);
        }
    }

##### 6.2 案例2：存储自定义类型的对象 #####

> **需求：**
> 
> 某影院系统需要在后台存储上述三部电影，然后依次展示出来。
> 
> **分析：**
> 
> 1.定义一个电影类，定义一个集合存储电影对象。
> 
> 2.创建3个电影对象，封装相关数据，把3个对象存入到集合中去。
> 
> 3.遍历集合中的3个对象，输出相关信息。

public class Movie {
        private String name;
        private double score;
        private String actor;
    
        public Movie() {
        }
    
        public Movie(String name, double score, String actor) {
            this.name = name;
            this.score = score;
            this.actor = actor;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public double getScore() {
            return score;
        }
    
        public void setScore(double score) {
            this.score = score;
        }
    
        public String getActor() {
            return actor;
        }
    
        public void setActor(String actor) {
            this.actor = actor;
        }
    }

/**
        案例：集合存储自定义元素并遍历。
        需求：定义电影类（名称，分值，演员），创建3个电影对象，代表三部影片，存入集合中并遍历。
        《肖生克的救赎》, 9.7 , 罗宾斯
        《霸王别姬》, 9.6 , 张国荣、张丰毅
        《阿甘正传》, 9.5 , 汤姆.汉克斯
     */
    public class ArrayListTest2 {
        public static void main(String[] args) {
            // 1、定义一个电影类：Movie
            // 2、定义一个ArrayList集合存储这些影片对象。
            ArrayList<Movie> movies = new ArrayList<>();
    
            // 3、创建影片对象封装电影数据，把对象加入到集合中去。
    //        Movie m1 = new Movie("《肖生克的救赎》", 9.7 , "罗宾斯");
    //        movies.add(m1);
            movies.add(new Movie("《肖生克的救赎》", 9.7 , "罗宾斯"));
            movies.add(new Movie("《霸王别姬》", 9.6 , "张国荣、张丰毅"));
            movies.add(new Movie("《阿甘正传》", 9.5 , "汤姆.汉克斯"));
    
            System.out.println(movies);
    
            // 4、遍历集合中的影片对象并展示出来
            for (int i = 0; i < movies.size(); i++) {
                Movie movie = movies.get(i);
                System.out.println("片名：" + movie.getName());
                System.out.println("评分：" + movie.getScore());
                System.out.println("主演：" + movie.getActor());
            }
        }
    }

![e592eba79833460fa540d5d70af34f6f.png][]

#### 6.3 案例3：元素搜索 ####

![89d906844c304e298a2f09a4248a3481.png][]

> **需求：**
> 
> 后台程序需要存储如上学生信息并展示，然后要提供按照学号搜索学生信息的功能。
> 
> **分析：**
> 
> 1.定义Student类，定义ArrayList集合存储如上学生对象信息，并遍历展示出来。
> 
> 2.提供一个方法，可以接收ArrayList集合，和要搜索的学号，返回搜索到的学生对象信息，并展示。
> 
> 3.使用死循环，让用户可以不停的搜索。

public class Student {
        private String studyId;
        private String name;
        private int age;
        private String className;
    
        public Student() {
        }
    
        public Student(String studyId, String name, int age, String className) {
            this.studyId = studyId;
            this.name = name;
            this.age = age;
            this.className = className;
        }
    
        public String getStudyId() {
            return studyId;
        }
    
        public void setStudyId(String studyId) {
            this.studyId = studyId;
        }
    
        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 getClassName() {
            return className;
        }
    
        public void setClassName(String className) {
            this.className = className;
        }
    }

/**
        案例：学生信息系统：展示数据，并按照学号完成搜索
         学生类信息（学号，姓名，性别，班级）
         测试数据：
         "20180302","叶孤城",23,"护理一班"
         "20180303","东方不败",23,"推拿二班"
         "20180304","西门吹雪",26,"中药学四班"
         "20180305","梅超风",26,"神经科2班"
     */
    public class ArrayListTest6 {
        public static void main(String[] args) {
            // 1、定义一个学生类，后期用于创建对象封装学生数据
            // 2、定义一个集合对象用于装学生对象
            ArrayList<Student> students = new ArrayList<>();
            students.add(new Student("20180302","叶孤城",23,"护理一班"));
            students.add(new Student("20180303","东方不败",23,"推拿二班"));
            students.add(new Student( "20180304","西门吹雪",26,"中药学四班"));
            students.add(new Student( "20180305","梅超风",26,"神经科2班"));
            System.out.println("学号\t\t名称\t年龄\t\t班级");
    
            // 3、遍历集合中的每个学生对象并展示其数据
            for (int i = 0; i < students.size(); i++) {
                Student s = students.get(i);
                System.out.println(s.getStudyId() +"\t\t" + s.getName()+"\t\t"
                        + s.getAge() +"\t\t" + s.getClassName());
            }
    
            // 4、让用户不断的输入学号，可以搜索出该学生对象信息并展示出来（独立成方法）
            Scanner sc = new Scanner(System.in);
            while (true) {
                System.out.println("请您输入要查询的学生的学号：");
                String id = sc.next();
                Student s = getStudentByStudyId(students, id);
                // 判断学号是否存在
                if(s == null){
                    System.out.println("查无此人！");
                }else {
                    // 找到了该学生对象了，信息如下
                    System.out.println(s.getStudyId() +"\t\t" + s.getName()+"\t\t"
                            + s.getAge() +"\t\t" + s.getClassName());
                }
            }
        }
    
        /**
          根据学号，去集合中找出学生对象并返回。
         * @param students
         * @param studyId
         * @return
         */
        public static Student getStudentByStudyId(ArrayList<Student> students, String studyId){
            for (int i = 0; i < students.size(); i++) {
                Student s = students.get(i);
                if(s.getStudyId().equals(studyId)){
                    return s;
                }
            }
            return null; // 查无此学号！
        }
    }

[c043136fa8234464a3e713713a8f6634.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/e30b73bb4a8f4fa382bb0fa73ee66180.png
[aee29273fb8b42d89324fd83645224c1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/67ff9c67ce504e65bc976f347ef2b1f6.png
[23ba4c9a837049f197263cb3cb20af52.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/83920004cefb4fc997bbf8177dd892ae.png
[9e136bc224de4a2eaa2ed589340a57cc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/f54428a7e1084138abcc8519eaf5e82c.png
[88738d01167c488689dc1f037f8d3528.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/d4e09bb622ad455faa70d58343d99d32.png
[a6246e0679524c09b8bfe81d6623fb2b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/6740c68dc1a1404f8d57e5fda2c54766.png
[831c5904a1824a019eade40201f09811.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/9200837d5d86414dbd718b05fb18b71d.png
[25f20a3abeee4898a56cc79465248e6e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/c369f9af107a48c0bab1050de686b011.png
[cb058a40a30a40eca0ab1cdf71833da7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/e83e5d3f776c4da79275a3dceac7a88b.png
[61c447f6adae4464b708ce3a3c26d5c8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/2188d8e8f1f041458add6fc9380196c7.png
[2fa59f363e1b4070a377b5ac78085bb1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/faa0421a69fb487cb6191f67b1d880d4.png
[4dd2f5c2c53742c0b559d34af9f55f12.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/3b36bbb6c7124dae9047957ee38c5d32.png
[fcfb1e7fe6834b0d83518d5572a380e9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/c87ef222db5f43fb8fd025f63c388ae0.png
[1986d678755e491aa0207fdb4313dcb7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/e831246c80974ecaab76d227a6d7aa2e.png
[71b0e46cfbd04b47bfba05d3995eeefa.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/b236aac08c1c47d48731e825217768da.png
[a9ebf92550d040c99f9a0143b7a97186.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/de5cd1974a744e38954013ddc493bac5.png
[cdc0dd251ad94ac9bf28f197fe39a64a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/e8bf37edba604d7fb4a6c04a5cfe1fe8.png
[caf63bbdb76e46d8b9893d04ba65ceca.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/cceecff25074419ebc2cfeb14adcd2fa.png
[09fc576920a84a23bd1a083f254d843e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/a35e25c12a9f4dc7910d82c6bb78913b.png
[43e82fe941a74ffda4fb6262a2f98bc0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/47f0d212c065462fa168ca67f5a27d52.png
[08d907e583b74a43b785d0b2cc5273be.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/4e72b4bb088041f495f596d899202990.png
[5a452298fa084c49b6d64dce61b437f3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/2ca5a894697a4aadbe8a3faf309c4ed3.png
[7b1344f7d8db4724b6771b0f9577ec2d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/b0e16d9057d041358d59079d457b27ae.png
[e592eba79833460fa540d5d70af34f6f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/4cfc927854bd42d3922c67a6d9131bda.png
[89d906844c304e298a2f09a4248a3481.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/f829647da108451c91e272a46b77ce57.png