【Java基础】08 常用API(String、集合)

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

• Java写好的程序(功能)，咱们可以直接调用。
• Oracle 也为Java提供的这些功能代码提供了相应的 API文档(使用说明书) 。

String

• String类定义的变量可以用于存储字符串，同时String类提供了很多操作字符串的功能，我们可以直接使用。

• 关于String类需要学会什么？

  1. String定义变量存储字符串：需要知道如何创建字符串对象，并使用String定义变量指向该字符串对象
  2. String的内存原理：字符串对象在内存中的原理是什么样。能够解决一些字符串的常见面试题
  3. String类提供了哪些API：能够说出并使用String类提供的操作字符串的功能：遍历、替换、截取、相等，包含…
  4. String解决实际案例：能够利用String的常用API去解决实际场景的业务需求，真正做到学以致用

String类概述

• java.lang.String 类代表字符串，String类定义的变量可以用于指向字符串对象，然后操作该字符串。
• Java 程序中的所有字符串文字（例如“abc”）都为此类的对象。

  String name = "小黑";
  String schoolName = "元宇宙工程大学";

String类的特点详解

• String其实常被称为不可变字符串类型，它的对象在创建后不能被更改。

• 从下方代码可以看出字符串变量name指向的字符串对象，那为何还说字符串不可变呢？

  String name = "元宇宙";
  name += "工程";
  name +="大学";
  System.out.println(name); // 元宇宙工程大学

• 字符串对象存在哪里？以“”方式给出的字符串对象，在字符串常量池中存储。

  

• String是什么，可以做什么？
  字符串类型，可以定义字符串变量指向字符串对象。

• String是不可变字符串的原因？
  String变量每次的修改其实都是产生并指向了新的字符串对象。原来的字符串对象都是没有改变的，所以称不可变字符串。

String类常用方法-字符串内容比较

• 从下方代码可以看出，字符串的内容比较不适合用“==”

  public static void main(String[] args) {
      String username = "小黑";
  
      Scanner scanner = new Scanner(System.in);
      System.out.print("请输入您的用户名：");
      String inputName = scanner.next();
  
      System.out.println(username == inputName); // false
  }

• 字符串的内容比较：推荐使用String类提供的 equals 比较：只关心内容一样即可

  方法名	说明
  public boolean equals (Object anObject)	将此字符串与指定对象进行比较。只关心字符内容是否一致！
  public boolean equalsIgnoreCase (String anotherString)	将此字符串与指定对象进行比较，忽略大小写比较字符串。只关心字符内容是否一致！

public static void main(String[] args) {
    String username = "admin";

    Scanner scanner = new Scanner(System.in);
    System.out.print("请输入您的用户名：");
    String inputName = scanner.next();

    // 1. ==比较的是地址值
    System.out.println(username == inputName);

    // 2. equals比较字符内容
    System.out.println(username.equals(inputName)); // 比较内容
    System.out.println(username.equalsIgnoreCase(inputName));  // 忽略大小写，比较内容
}

• 如果是字符串比较应该使用使用什么方式进行比较，为什么？
  使用String提供的equals方法。只关心内容一样就返回true。

• 开发中什么时候使用==比较数据
  基本数据类型比较时使用。

String类的常用方法-遍历、替换、截取、分割操作

更多方法请见JDK API文档里String类的方法摘要

package study;

import java.util.Arrays;

public class Demo03 {
    public static void main(String[] args) {

        String str = "madongmei";

        //1. pulic int length() 返回此字符串的长度
        System.out.println(str.length());

        //2. char charAt(int index) 返回指定索引处的char值
        char c = str.charAt(2);
        System.out.println(c);

        //3. public char[] toCharArray() 将当前字符串转换成字符数组返回
        char[] chars = str.toCharArray();
        System.out.println(Arrays.toString(chars)); // 用字符串类型输出数组

        //4. public String substring(int beginIndex, int endIndex) 根据开始和结束索引进行截取，得到新的字符串（包前不包后）
        String s4 = str.substring(3, 5);
        System.out.println(s4);

        //5. public String substring(int beginIndex) 从传入的索引处截取，截取到末尾，得到新的字符串
        String s5 = str.substring(3);
        System.out.println(s5);

        //6. public String replace(CharSequence target, CharSequence replacement)  使用新值，将字符串中的旧值替换，得到新的字符串
        String s6 = str.replace("m", "o");
        System.out.println(s6);

        //7. public String[] split(String regex) 根据传入的规则切割字符串，得到字符串数组返回
        String[] s7 = str.split("o"); // madongmei  根据o切割
        System.out.println(Arrays.toString(s7));

        //8. split常用于地址 数组切割
        String adress = "河南省,新乡市,牧野区";
        String[] s8 = adress.split(",");
        System.out.println(Arrays.toString(s8));
    }
}

String类案例实战

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

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

package study;

import java.util.Random;

/**
 * String类开发验证码功能
 */
public class Demo04 {
    public static void main(String[] args) {
        String characterPool = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";

        Random random = new Random();
        String code = "";
        for (int i = 1; i <= 5; i++) {
            int index = random.nextInt(characterPool.length() + 1);
            code += characterPool.charAt(index);
        }

        System.out.println(code);
    }
}

案例：模拟用户登录功能

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

package study;

import java.util.Scanner;

/**
 * 模拟用户登录功能
 */
public class Demo05 {
    public static void main(String[] args) {
        String username = "admin";
        String password = "123456";

        Scanner scanner = new Scanner(System.in);
        for (int i = 1; i <= 3; i++) {
            System.out.print("请输入用户名：");
            String usernameInput = scanner.next();
            System.out.print("请输入密码：");
            String passwordInput = scanner.next();
            if (username.equals(usernameInput) && password.equals(passwordInput)) {
                System.out.println("登陆成功！");
                break;
            } else {
                System.out.println("登录失败，还有" + (3-i) + "次机会");
            }
        }
    }
}

案例：手机号码屏蔽

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

package study;

import java.util.Scanner;

/**
 * 手机号码屏蔽
 */
public class Demo06 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入11位手机号码：");
        String phone = scanner.next();
        String a = phone.substring(0, 3);
        String b = phone.substring(7, 11);
        String phoneShow = a + "****" + b;
        System.out.println("手机号码脱敏后：" + phoneShow);
    }
}

String类创建对象的2种方式

package study;

/**
 * String类创建对象的2种方式
 */
public class Demo07 {
    public static void main(String[] args) {
        //1. 直接用“”定义
        String name = "百里飞洋";
        System.out.println(name);

        //2. 使用构造器创建
        //2.1 使用无参构造 public String()
        String s1 = new String(); // 空字符串“”
        System.out.println(s1);
        System.out.println("@"+s1+"@");

        //2.2 传递一个字符串 public String(String original)
        String s2 = new String("fly");
        System.out.println(s2);

        //2.3 传递一个字符数组 public String(char[] chs)
        // 例 {'a', 'b', 'c', 'd'};  'b'-->'B'
        char[] chs = {'a', 'b', 'c', 'd'};
        String s3 = new String(chs);
        System.out.println(s3); // abcd

        //2.4 传递一个字节数组 public String(byte[] chs)
        // 将数字转成字符串拼接
        byte[] bytes = {97, 98, 99};
        String s4 = new String(bytes);
        System.out.println(s4); // abc
    }
}

• 有什么区别吗？（面试常考）

  1. 以“”方式给出的字符串对象，在字符串常量池中存储，而且相同内容只会在其中存储一份。
  2. 通过构造器new对象，每new一次都会产生一个新对象，放在堆内存中。

     String s1 = "abc";
     String s2 = "abc";
     System.out.println(s1 == s2); // true
     
     char[] chs = {'a', 'b', 'c'};
     String s3 = new String(chs);
     String s4 = new String(chs);
     System.out.println(s3 == s4); // false

• 字符串对象的特点有哪些？

  • 双引号创建的字符串对象，在字符串常量池中存储同一个。
  • 通过new 构造器创建的字符串对象，在堆内存中分开存储。

String类常见面试题

• 问题：下列代码的运行结果是？

  public class Test2 {
    public static void main(String[] args) {
      String s2 = new String("abc"); // 这句代码实际上创建了两个对象
          
      String s1 = "abc";
      System.out.println(s1 == s2); // false
    }
  }

  public class Test3 {
    public static void main(String[] args) {
      String s1 = "abc";
      String s2 = "ab";
      String s3 = s2 + "c";
      System.out.println(s1 == s3); // false
    }
  }

  // Java存在编译优化机制，程序在编译时： “a” + “b” + “c” 会直接转成 "abc"
  public class Test4 {
    public static void main(String[] args) {
      String s1 = "abc";
      String s2 = "a" + "b" + "c";
      System.out.println(s1 == s2); // true
    }
  }

---

ArrayList

集合概述

集合是与数组类似，也是一种容器，用于装数据的。

• 数组的特点

  1. 数组定义完成并启动后，类型确定、长度固定。
  2. 问题：在个数不能确定，且要进行增删数据操作的时候，数组是不太合适的。

• 集合的特点

  1. 集合的大小不固定，启动后可以动态变化，类型也可以选择不固定。
  2. 集合非常适合做元素个数不确定，且要进行增删操作的业务场景。
  3. 集合还提供了许多丰富、好用的功能，而数组的功能很单一。

• 数组和集合的元素存储的个数问题?

  • 数组定义后类型确定，长度固定
  • 集合类型可以不固定，大小是可变的。

• 数组和集合适合的场景

  • 数组适合做数据个数和类型确定的场景
  • 集合适合做数据个数不确定，且要做增删元素的场景

ArrayList集合快速入门

• ArrayList集合：ArrayList是集合中的一种，它支持索引。（暂时先学习这个，后期课程会学习整个集合体系）

• ArrayList集合的对象的创建

  构造器	说明
  public ArrayList()	创建一个空的集合对象

• ArrayList集合的添加元素的方法

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

• ArrayList类是如何创建集合对象的，如何添加元素？
  • public ArrayList​()
  • public boolean add(E e)
  • public void add(int index, E element)

ArrayList对于泛型的支持

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

• 举例：

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

注意：泛型只能支持引用数据类型，不支持基本数据类型。可浏览博文：包装类(基本概念和一些使用方法)

• 怎么去统一ArrayList集合操作的元素类型，泛型需要注意什么？
  • 使用泛型：<数据类型>
  • 创建集合对象都应该使用泛型。
  • ArrayList<String> list1 = new ArrayList();
  • 泛型只能支持引用数据类型，不支持基本数据类型。

ArrayList常用方法、遍历

增删改查方法练习：

package study;

import java.util.ArrayList;

/**
 * ArrayList集合快速入门
 */
public class Demo08 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        System.out.println(list);

        // 添加元素
        // add(E e)   将指定的元素追加到此列表的末尾。
        list.add("百里");
        list.add("飞洋");
        list.add("aaa");
        System.out.println(list);
        // add(int index, E element)   在此列表中的指定位置插入指定的元素。
        list.add(0, "aaa");
        System.out.println(list);

        // 删除元素
        // remove(Object o)   从列表中删除指定元素的第一个出现（如果存在）。
        boolean b1 = list.remove("bbb");
        System.out.println(b1); // false
        System.out.println(list);
        boolean b2 = list.remove("aaa");
        System.out.println(b2); // true
        System.out.println(list);
        // remove(int index)   删除该列表中指定位置的元素。
        list.remove(2);
        System.out.println(list);


        // 修改元素
        // set(int index,  element)   用指定的元素替换此列表中指定位置的元素。
        list.set(1, "守约");
        System.out.println(list);

        // 获取元素
        // get(int index)   返回此列表中指定位置的元素。
        System.out.println(list.get(0));
    }
}

控制台输出：

[]
[百里, 飞洋, aaa]
[aaa, 百里, 飞洋, aaa]
false
[aaa, 百里, 飞洋, aaa]
true
[百里, 飞洋, aaa]
[百里, 飞洋]
[百里, 守约]
百里

• ArrayList类遍历元素？（List集合遍历的五种方式）

  // 普通for循环遍历
  for (int i = 0; i < list.size(); i++) {
      System.out.println(list.get(i));
  }
  
  // 增强for循环遍历
  for (String s1 : list) {
      System.out.println(s1);
  }

案例：遍历并删除元素值

• 需求：

  • 某个班级的考试在系统上进行，成绩大致为：98, 77, 66, 89, 79, 50, 100
  • 现在需要先把成绩低于80分以下的数据去掉。

• 分析：

  • 定义ArrayList集合存储多名学员的成绩。
  • 遍历集合每个元素，如果元素值低于80分，去掉它。

ArrayList<Integer> list = new ArrayList<>();
    list.add(98);
    list.add(77);
    list.add(66);
    list.add(89);
    list.add(79);
    list.add(50);
    list.add(100);
    System.out.println(list);

// 方法一：遍历删除小于80的
for (int i = 0; i < list.size(); i++) {
    if (list.get(i) < 80) {
        list.remove(i); // 把集合里第i个去掉
        i--; // i=7时，删去77，此时66会顶上来，如果没有i--，电脑会直接拿i=2，即89，从而跳过66
    }
}

System.out.println(list);

// 方法二：遍历删除小于80的（倒着删）
for (int i = list.size() - 1; i >= 0; i--) {
    if (list.get(i) < 80) {
        list.remove(i); // i=6时，删去50
    }
}

• 从集合中遍历元素，并筛选出元素删除它，应该怎么解决？
  从集合后面遍历然后删除，可以避免漏掉元素。

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

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

package study;

public class Movie {
    // 成员变量 (属性)
    private String name;
    private double score;
    private String area;
    private String type;
    private String director;
    private String actor;

    // 无参数构造器
    public Movie(){
    }
    // 有参数构造器
    public Movie(String name, double score, String area, String type, String director, String actor) {
        this.name = name;
        this.score = score;
        this.area = area;
        this.type = type;
        this.director = director;
        this.actor = actor;
    }

    // 成员方法（行为）
    // Getter / Setter
    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 getArea() {
        return area;
    }

    public void setArea(String area) {
        this.area = area;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public String getDirector() {
        return director;
    }

    public void setDirector(String director) {
        this.director = director;
    }

    public String getActor() {
        return actor;
    }

    public void setActor(String actor) {
        this.actor = actor;
    }
}

package study;

import java.util.ArrayList;

/**
 * 存储自定义类型的对象：影片信息在程序中的表示
 */
public class Demo10 {
    public static void main(String[] args) {
        // 创建3个电影对象，封装相关数据，把3个对象存入到集合中去。
        ArrayList<Movie> movies = new ArrayList<>();
        movies.add(new Movie("《隐入尘烟》", 8.5, "中国大陆", "剧情", "李睿珺", "武仁林/海清/杨光锐/武赟志/李生甫"));
        movies.add(new Movie("《霸王别姬》", 9.6, "中国大陆/中国香港", "剧情/爱情", "陈凯歌", "张国荣/张丰毅/巩俐/葛优/英达"));
        movies.add(new Movie("《千与千寻》", 9.4, "日本", "剧情/动画/奇幻", "宫崎骏", "柊瑠美/入野自由/夏木真理/菅原文太/中村彰男"));

        System.out.println(movies);

        // 遍历集合中的3个对象，输出相关信息。
        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());
            System.out.println("======================");
        }
    }
}

案例：元素搜索

• 学生信息系统的数据搜索
• 需求：后台程序需要存储如上学生信息并展示，然后要提供按照学号搜索学生信息的功能。

  学号	姓名	年龄	班级
  20180208	郑爽	31	月嫂班
  20190302	吴亦凡	32	缝纫机班
  20200405	李云迪	40	清洁工班
  20210709	李易峰	35	造月饼班

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

package study;

public class Student {
    private int stuId; // 学号
    private String name; // 姓名
    private int age; // 年龄
    private String classroom; // 班级

    public Student() {
    }

    public Student(int stuId, String name, int age, String classroom) {
        this.stuId = stuId;
        this.name = name;
        this.age = age;
        this.classroom = classroom;
    }

    public int getStuId() {
        return stuId;
    }

    public void setStuId(int stuId) {
        this.stuId = stuId;
    }

    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 getClassroom() {
        return classroom;
    }

    public void setClassroom(String classroom) {
        this.classroom = classroom;
    }

    @Override
    public String toString() {
        return "Student{" +
                "stuId=" + stuId +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", classroom='" + classroom + '\'' +
                '}';
    }
}

package study;

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

/**
 * 元素搜索：学生信息系统的数据搜索
 */
public class Demo11 {
    public static void main(String[] args) {
        ArrayList<Student> students = new ArrayList<>();
        // 录入学员信息
        students.add(new Student(20180208, "郑爽", 31, "月嫂班"));
        students.add(new Student(20190302, "吴亦凡", 32, "缝纫机班"));
        students.add(new Student(20200405, "李云迪", 40, "清洁工班"));
        students.add(new Student(20210709, "李易峰", 35, "造月饼班"));

        // 展示学员信息
        for (Student student : students) {
            System.out.println(student);
        }

        // 搜索
        Scanner scanner = new Scanner(System.in);
        while (true) {
            System.out.print("请输入要找的学号：");
            int id = scanner.nextInt();

            // 循环集合匹配ID
            boolean b = false;
            for (int i = 0; i < students.size(); i++) {
                Student student = students.get(i);
                if (student.getStuId() == id) {
                    b = true;
                    System.out.println("该学生已找到，目前正在北京朝阳区派出所，信息如下 ：");
                    System.out.println(student);
                }
            }
            if (!b) {
                System.out.println("抱歉，该学生已出狱！");
            }
        }
    }
}

---

【参考内容】：

• List集合遍历的五种方式
• 包装类(基本概念和一些使用方法)