4. Java集合、API (上)

---

1. API

2. String

2.1 概述

2.2 String类创建对象的2种方式

2.3 String类常见面试题

2.4 String类常用API-字符串内容比较

2.5 String类常用API-遍历、替换、截取、分割操作

2.6 String类案例实战

import java.util.Random;

public class StringExercise {
    public static void main(String[] args) {
        String data = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";

        String code = "";
        Random r = new Random();
        for (int i = 0; i < 5; i++) {
            int index = r.nextInt(data.length());
            char c = data.charAt(index);
            code += c;
        }
        System.out.println(code);
    }
}

import java.util.Scanner;

public class StringExercise {
    public static void main(String[] args) {
        String okName = "admin";
        String okPassword = "123";

        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < 3; i++) {
            System.out.println("请输入登录名称：");
            String loginName = sc.next();
            System.out.println("请输入登录密码：");
            String loginPassword = sc.next();

            if(okName.equals(loginName)){
                if(okPassword.equals(loginPassword)){
                    System.out.println("登录成功");
                    break;
                }else{
                    System.out.println("密码不正确！您剩余" + (3-i) + "次机会");
                }
            }else{
                System.out.println("名称不正确！您剩余" + (3-i) + "次机会");
            }
        }
    }
}

import java.util.Scanner;

public class StringExercise {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入您的手机号：");
        String tel = sc.next();

        String before = tel.substring(0, 3);
        String after = tel.substring(7);

        String s = before + "****" + after;
        System.out.println(s);
    }
}

3. ArrayList

3.1 概述

3.2 ArrayList对泛型的支持

3.3 ArrayList常用API

3.4 ArrayList集合案例

3.4.1 遍历并删除元素

import java.util.ArrayList;

public class ArrayListTest {
    public static void main(String[] args) {
        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]

            //从前面开始删除会出bug，因为后面会补到前面被删元素的位置
//        for (int i = 0; i < scores.size(); i++) {
//            int score = scores.get(i);
//            if (score < 80){
//                scores.remove(i);
//            }
//        }

        for (int i = scores.size() - 1; i >= 0; i--) {
            int score = scores.get(i);
            if (score < 80) {
                scores.remove(i);
            }
        }
        System.out.println(scores);
    }
}

3.4.2 存储自定义类型的对象

import java.util.ArrayList;

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;
    }
}

public class ArrayListTest {
    public static void main(String[] args) {
        ArrayList<Movie> movies = new ArrayList<>();

//        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, "汤姆汉克斯"));

        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());
        }
    }
}

3.4.3 元素搜索

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

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;
    }
}

public class ArrayListTest {
    public static void main(String[] args) {
        ArrayList<Student> students = new ArrayList<>();
        students.add(new Student("20211209", "Mike", 23, "数学一班"));
        students.add(new Student("20210323", "Jack", 21, "数学二班"));
        students.add(new Student("20211202", "Lee", 29, "金融一班"));
        students.add(new Student("20211123", "Ben", 23, "数学一班"));

        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());
        }
        while (true) {
            Scanner sc = new Scanner(System.in);
            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());
            }
        }
    }

    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;
    }
}

4. 常用API

4.1 Object

4.1.1 toString方法

public class Student { //extends Object{
    private String name;
    private char sex;
    private int age;

    public Student() {}

    public Student(String name, char sex, int age) {
        this.name = name;
        this.sex = sex;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() { //快捷方式：输入toS + Enter
        return "Student{" +
                "name='" + name + '\'' +
                ", sex=" + sex +
                ", age=" + age +
                '}';
    }
}

public class Test {
    public static void main(String[] args) {
        Student s = new Student("周雄", '男', 19);
         String rs = s.toString();
         //重写toString方法之前
         // System.out.println(rs); //com.buluchacha.Student@4eec7777

        //重写toString方法之后
        // 直接输出对象变量，默认可以省略toString调用不写的
        System.out.println(s.toString()); //Student{name='周雄', sex=男, age=19}
        System.out.println(s); //Student{name='周雄', sex=男, age=19}
    }
}

4.1.2 equals方法

import java.util.Objects;

public class Student { //extends Object{
    private String name;
    private char sex;
    private int age;

    public Student() {}

    public Student(String name, char sex, int age) {
        this.name = name;
        this.sex = sex;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    /**
     定制相等规则。
     两个对象的内容一样就认为是相等的
     s1.equals(s2)
     比较者：s1 == this
     被比较者： s2 ==> o
     */

    /**
    //第一版：
    @Override
    public boolean equals(Object o) {
        // 1、判断o是不是学生类型
        if (o instanceof Student) {
            Student s2 = (Student) o;
            //2、判断2个对象的内容是否一样。
            if (this.name.equals(s2.name) &&
                    this.age == s2.age && this.sex == s2.sex) {
                return true;
            } else {
                return false;
            }
        }else{
            //学生只能和学生比较，否则结果一定是false
            return false;
        }
    }
    */

    /**
    //第二版简化：
    @Override
    public boolean equals(Object o) {
        // 1、判断o是不是学生类型
        if (o instanceof Student) {
            Student s2 = (Student) o;
            return this.name.equals(s2.name) && this.age == s2.age
                    && this.sex == s2.sex ;
        }else {
            // 学生只能和学生比较，否则结果一定是false
            return false;
        }
    }
    */

    //第三版官方自动生成 - Generator->equals->一直continue到finish
    @Override
    public boolean equals(Object o) {
        // 1、判断是否是同一个对象比较，如果是返回true。
        if (this == o) return true;
        // 2、如果o是null返回false  如果o不是学生类型返回false  ...Student !=  ..Pig
        if (o == null || this.getClass() != o.getClass()) return false;
        // 3、说明o一定是学生类型而且不为null
        Student student = (Student) o;
        return sex == student.sex && age == student.age && Objects.equals(name, student.name);
    }
}

public class Test {
    public static void main(String[] args) {
        Student s1 = new Student("周雄", '男', 19);
        Student s2 = new Student("周雄", '男', 19);

        //重写equals方法前
        // equals默认是比较2个对象的地址是否相同，子类重写后会调用子类重写的来比较内容是否相同。
        // System.out.println(s1.equals(s2)); //false
        // System.out.println(s1 == s2); //false

        //重写equals方法后
        System.out.println(s1.equals(s2)); //true
        System.out.println(s1 == s2); //false
        System.out.println(Objects.equals(s1, s2)); //true
    }
}

4.2 Objects

import java.util.Objects;

public class Test {
    public static void main(String[] args) {
        String s1 = null;
        String s2 = new String("itheima");

        // System.out.println(s1.equals(s2));   //报错
        // 留下了隐患，可能出现空指针异常。

        System.out.println(Objects.equals(s1, s2)); //false
        // 更安全，结果也是对的！

        /**
         Java官方源码：
         Objects：
         public static boolean equals(Object a, Object b) {
         return (a == b) || (a != null && a.equals(b));
         }
         */

        System.out.println(Objects.isNull(s1)); // true
        System.out.println(s1 == null); // true

        System.out.println(Objects.isNull(s2)); // false
        System.out.println(s2 == null); // false

    }
}

4.3 StringBuilder

public class Test { //演示怎么操作字符串
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        sb.append("a");
        sb.append("b");
        sb.append("c");
        sb.append(1);
        sb.append(false);
        sb.append(3.3);
        sb.append("abc");
        System.out.println(sb); //abc1false3.3abc

        // 支持链式编程
        StringBuilder sb1 = new StringBuilder();
        sb1.append("a").append("b").append("c").append("我爱你中国");
        System.out.println(sb1); //abc我爱你中国

        // 反转
        sb1.reverse().append("110");
        System.out.println(sb1); //国中你爱我cba110
        System.out.println(sb1.length()); //11

        // 注意：StringBuilder只是拼接字符串的手段：效率好。
        // 最终的目的还是要恢复成String类型。
        StringBuilder sb2 = new StringBuilder();
        sb2.append("123").append("456");
        // 恢复成String类型
        String rs = sb2.toString();
        check(rs); //123456
    }

    public static void check(String data){
        System.out.println(data);
    }
}

public class Test { 
    public static void main(String[] args) {
        int[] arr1 = null;
        System.out.println(toString(arr1)); //null

        int[] arr2 = {10, 88, 99};
        System.out.println(toString(arr2)); //[10, 88, 99]

        int[] arr3 = {};
        System.out.println(toString(arr3)); //[]
    }

    /**
     1、定义方法接收任意整型数组，返回数组内容格式
     */
    public static String toString(int[] arr){
        if(arr != null){
            // 2、开始拼接内容。
            StringBuilder sb = new StringBuilder("[");
            for (int i = 0; i < arr.length; i++) {
                sb.append(arr[i] ).append(i == arr.length - 1 ? "" : ", ");
            }
            sb.append("]");
            return sb.toString();
        }else {
            return null;
        }
    }
}

4.4 Math

public class Test {
    public static void main(String[] args) {
        // 1.取绝对值:返回正数
        System.out.println(Math.abs(10)); // 10
        System.out.println(Math.abs(-10.3)); // 10.3

        // 2.向上取整: 5
        System.out.println(Math.ceil(4.00000001)); // 5.0
        System.out.println(Math.ceil(4.0)); // 4.0
        // 3.向下取整：4
        System.out.println(Math.floor(4.99999999)); // 4.0
        System.out.println(Math.floor(4.0)); // 4.0

        // 4.求指数次方
        System.out.println(Math.pow(2 , 3)); // 2^3 = 8.0
        // 5.四舍五入 10
        System.out.println(Math.round(4.49999)); // 4
        System.out.println(Math.round(4.500001)); // 5

        System.out.println(Math.random());  //0.9684474754264328
        // 0.0 - 1.0 （包前不包后）

        // 拓展： 3 - 9 之间的随机数  （0 ~ 6） + 3
        //  [0 ~ 6] + 3
        int data =  (int)(Math.random() * 7) + 3;
        System.out.println(data);
    }
}

4.5 System

import java.util.Arrays;

public class Test {
    public static void main(String[] args) {
        System.out.println("程序开始。。。");
        // System.exit(0); // 不要用这个退出!

        // 计算机认为时间有起源：返回1970-1-1 00：00：00 走到此刻的总的毫秒值：时间毫秒值。
        long time = System.currentTimeMillis();
        System.out.println(time);

        long startTime = System.currentTimeMillis();
        // 进行时间的计算：性能分析
        for (int i = 0; i < 100000; i++) {
            System.out.println("输出：" + i);
        }
        long endTime = System.currentTimeMillis();
        System.out.println((endTime - startTime)/1000.0 + "s");


        // 做数组拷贝（了解）
        /**
         arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
         参数一：被拷贝的数组
         参数二：从哪个索引位置开始拷贝
         参数三：复制的目标数组
         参数四：粘贴位置
         参数五：拷贝元素的个数
         */
        int[] arr1 = {10, 20, 30, 40, 50, 60, 70};
        int[] arr2 = new int[6]; // [0, 0, 0, 0, 0, 0] ==>  [0, 0, 40, 50, 60, 0]
        System.arraycopy(arr1, 3, arr2, 2, 3);
        System.out.println(Arrays.toString(arr2)); //[0, 0, 40, 50, 60, 0]

        System.out.println("程序结束。。。。");
    }
}

4.6 BigDecimal

import java.math.BigDecimal;
import java.math.RoundingMode;

/**
 引入：
 浮点型运算的时候直接+  * / 可能会出现数据失真（精度问题）。
 BigDecimal可以解决浮点型运算数据失真的问题。

 BigDicimal类：
 包：java.math.
 创建对象的方式（最好的方式：）
 public static BigDecimal valueOf(double val) :包装浮点数成为大数据对象。
 方法声明
 public BigDecimal add(BigDecimal value)       加法运算
 public BigDecimal subtract(BigDecimal value)  减法运算
 public BigDecimal multiply(BigDecimal value)  乘法运算
 public BigDecimal divide(BigDecimal value)    除法运算
 public double doubleValue(): 把BigDecimal转换成double类型。
 */

public class Test {
    public static void main(String[] args) {
        // 浮点型运算的时候直接+  * / 可能会出现数据失真（精度问题）。
        System.out.println(0.09 + 0.01); //0.09999999999999999
        System.out.println(1.0 - 0.32); //0.6799999999999999
        System.out.println(1.015 * 100); //101.49999999999999
        System.out.println(1.301 / 100); //0.013009999999999999

        System.out.println("-------------------------");
        double a = 0.1;
        double b = 0.2;
        double c = a + b;
        System.out.println(c); //0.30000000000000004
        // 包装浮点型数据成为大数据对象 BigDeciaml
        BigDecimal a1 = BigDecimal.valueOf(a);
        BigDecimal b1 = BigDecimal.valueOf(b);
        BigDecimal c1 = a1.add(b1);
        // BigDecimal c1 = a1.subtract(b1);
        // BigDecimal c1 = a1.multiply(b1);
        // BigDecimal c1 = a1.divide(b1);
        System.out.println(c1); //0.3
        // 如果希望转成double：
        double rs = c1.doubleValue();
        System.out.println(rs); //0.3

        // 注意事项：BigDecimal是一定要精度运算的
        BigDecimal a11 = BigDecimal.valueOf(10.0);
        BigDecimal b11 = BigDecimal.valueOf(3.0);
        /**
         参数一：除数 参数二：保留小数位数  参数三：舍入模式
         */
        BigDecimal c11 = a11.divide(b11, 2, RoundingMode.HALF_UP); // 如果不能精确运算，就会报错
        System.out.println(c11); //3.33
    }
}

4.7 日期与时间相关API

4.7.1 Date

import java.util.Date;

public class Test {
    public static void main(String[] args) {
        // 1、创建一个Date类的对象：代表系统此刻日期时间对象
        Date d = new Date();
        System.out.println(d); //Sat Dec 11 11:32:51 CST 2021

        // 2、获取时间毫秒值
        long time = d.getTime();
        System.out.println(time); //1639193571129

        System.out.println("----------------------------");
        //案例：计算当前时间往后1小时121秒之后的时间
        // 1、得到当前时间
        Date d1 = new Date();
        System.out.println(d1); //Sat Dec 11 11:32:51 CST 2021

        // 2、当前时间往后走 1小时  121s
        long time2 = System.currentTimeMillis();
        time2 += (60 * 60 + 121) * 1000;

        // 3、把时间毫秒值转换成对应的日期对象。
        //方法一
        Date d2 = new Date(time2);
        System.out.println(d2); //Sat Dec 11 12:34:52 CST 2021

        //方法二
        Date d3 = new Date();
        d3.setTime(time2);
        System.out.println(d3); //Sat Dec 11 12:34:52 CST 2021
    }
}

4.7.2 SimpleDateFormat

import java.text.SimpleDateFormat;
import java.util.Date;

public class Test {
    public static void main(String[] args) {
        // 1、日期对象
        Date d = new Date();
        System.out.println(d); //Sat Dec 11 11:39:13 CST 2021

        // 2、格式化这个日期对象 (指定最终格式化的形式)
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss EEE a");
        // 3、开始格式化日期对象成为喜欢的字符串形式
        String rs = sdf.format(d);
        System.out.println(rs); //2021年12月11日 11:39:13 周六 上午

        System.out.println("----------------------------");

        // 4、格式化时间毫秒值
        // 需求：请问121秒后的时间是多少
        long time1 = System.currentTimeMillis() + 121 * 1000;
        String rs2 = sdf.format(time1);
        System.out.println(rs2); //2021年12月11日 11:41:14 周六 上午
    }
}

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Test {
    public static void main(String[] args) throws ParseException {
        // 目标: 学会使用SimpleDateFormat解析字符串时间成为日期对象。
        // 有一个时间 2021年08月06日 11:11:11 往后 2天 14小时 49分 06秒后的时间是多少。
        // 1、把字符串时间拿到程序中来
        String dateStr = "2021年08月06日 11:11:11";

        // 2、把字符串时间解析成日期对象（本节的重点）:形式必须与被解析时间的形式完全一样，否则运行时解析报错！
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        Date d = sdf.parse(dateStr);

        // 3、往后走2天 14小时 49分 06秒
        long time = d.getTime() + (2L*24*60*60 + 14*60*60 + 49*60 + 6) * 1000;

        // 4、格式化这个时间毫秒值就是结果
        System.out.println(sdf.format(time)); //2021年08月09日 02:00:17
    }
}

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Test {
    public static void main(String[] args) throws ParseException {
        // 1、开始 和 结束时间
        String startTime = "2021-11-11 00:00:00";
        String endTime = "2021-11-11 00:10:00";

        // 2、小贾 小皮
        String xiaoJia =  "2021-11-11 00:03:47";
        String xiaoPi =  "2021-11-11 00:10:11";

        // 3、解析他们的时间
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date d1 = sdf.parse(startTime);
        Date d2 = sdf.parse(endTime);
        Date d3 = sdf.parse(xiaoJia);
        Date d4 = sdf.parse(xiaoPi);

        if(d3.after(d1) && d3.before(d2)){
            System.out.println("小贾秒杀成功，可以发货了！");
        }else {
            System.out.println("小贾秒杀失败！");
        }

        if(d4.after(d1) && d4.before(d2)){
            System.out.println("小皮秒杀成功，可以发货了！");
        }else {
            System.out.println("小皮秒杀失败！");
        }
    }
}
//小贾秒杀成功，可以发货了！
//小皮秒杀失败！

4.7.3 Calendar

import java.util.Calendar;
import java.util.Date;

public class Test {
    public static void main(String[] args) {
        // 1、拿到系统此刻日历对象
        Calendar cal = Calendar.getInstance();
        System.out.println(cal);

        // 2、获取日历的信息:public int get(int field)：取日期中的某个字段信息。
        int year = cal.get(Calendar.YEAR);
        System.out.println(year); //2021

        int mm = cal.get(Calendar.MONTH) + 1;
        System.out.println(mm); //12

        int days = cal.get(Calendar.DAY_OF_YEAR) ;
        System.out.println(days); //345

        // 3、public void set(int field,int value)：修改日历的某个字段信息(一般不修改)。
        // cal.set(Calendar.HOUR , 12);
        // System.out.println(cal);

        // 4.public void add(int field,int amount)：为某个字段增加/减少指定的值
        // 请问64天后是什么时间
        cal.add(Calendar.DAY_OF_YEAR , 64);
        cal.add(Calendar.MINUTE , 59);

        //  5.public final Date getTime(): 拿到此刻日期对象。
        Date d = cal.getTime();
        System.out.println(d); //Sun Feb 13 12:55:42 CST 2022

        //  6.public long getTimeInMillis(): 拿到此刻时间毫秒值
        long time = cal.getTimeInMillis();
        System.out.println(time); //1644728142685
    }
}

4.8 JDK8新增日期类

4.8.1 LocalTime /LocalDate / LocalDateTime

4.8.2 Instant

4.8.3 DateTimeFormatter

4.8.4 Duration/Period

4.8.5 ChronoUnit