Java 进阶：时间与日期、包装类及正则表达式

时间毫秒值->日期对象

2. SimpleDateFormat

• 代表简单日期格式化，可以用来把日期时间格式化成为我们想要的形式。

构造器

格式化方法

SimpleDateFormat 解析字符串时间成为日期对象

public class SimpleDateFormatDemo1 {
    public static void main(String[] args) {
        // 1. 日期对象
        Date d = new Date();
        System.out.println(d);
        // 2. 格式化这个日期对象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy 年 MM 月 dd 日 HH:mm:ss EEE a");
        // 3. 开始格式化日期对象成为喜欢的字符串形式
        String rs = sdf.format(d);
        System.out.println(rs);
        System.out.println("--------------------");
        // 4. 格式化时间毫秒值
        // 121 秒后的时间毫秒值是多少
        long time = d.getTime() + 121 * 1000;
        String rs1 = sdf.format(time);
        System.out.println(rs1);
    }
}

public class SimpleDateFormatDemo2 {
    public static void main(String[] args) throws ParseException {
        // 目标：学会使用 SimpleDateFormat 解析字符串时间成为日期对象
        // 有一个时间 2021 年 08 月 06 日 11:11:11 往后 2 天 14 小时 49 分 04 秒的时间是多少
        // 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));
    }
}

练习：

public class SimpleDateFormatTest1 {
    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";
        String xiaoJia = "2021-11-11 00:03:47";
        String xiaoPi = "2021-11-11 00:10:11";
        // 2. 解析他们的时间
        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("小皮秒杀失败！");
        }
    }
}

3. Calendar

• Calendar 代表了系统此刻日期对应的日历对象。
• Calendar 是一个抽象类，不能直接创建对象。

Calendar 日历类创建日历对象的方法：

Calendar 常用方法

注意： Calendar 是可变日期对象，一旦修改后其对象本身表示的时间将产生变化。

public class CalendarDemo1 {
    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);
        // 3. public void add(int field, int amount); 为某个字段增加/减少指定的值
        cal.add(Calendar.DAY_OF_YEAR, 64);
        cal.add(Calendar.MINUTE, 59);
        System.out.println(cal);
        // 4. public final Date getTime(); 拿到此时日期对象
        Date d = cal.getTime();
        System.out.println(d);
    }
}

二、包装类

• 其实就是 8 种基本数据类型对应的引用类型。

• Java 为了实现一切皆对象，为 8 种基本类型提供了对应的引用类型。
• 后面的集合和泛型其实也只能支持包装类型，不支持基本数据类型。

自动装箱：基本类型的数据和变量可以直接赋值给包装类型的变量。 自动拆箱：包装类型的变量可以直接赋值给基本数据类型的变量。

包装类的特有功能

• 包装类的变量的默认值可以是 null，容错率更高。
• 可以把基本类型的数据转换成字符串类型 (用处不大)
  • ①调用 toString() 方法得到字符串结果。
  • ②调用 Integer.toString(基本类型的数据)。
• 可以把字符串类型的数值转换成真实的数据类型（有用）
  • ①Integer.parseInt("字符串类型的整数")
  • ②Double.parseDouble("字符串类型的小数")。

三、正则表达式

1. 正则表达式概述

• 正则表达式可以用一些规定的字符来制定规则，并用来校验数据格式的合法性。

字符串对象提供了匹配正则表达式的方法

• public boolean matches(String regex): 判断是否匹配正则表达式，匹配返回 true，不匹配返回 false

2. 案例

public class RegexDemo {
    public static void main(String[] args) {
        // 校验 手机号码 邮箱 电话号码
        //checkPhone();
        //checkEmail();
        checkTell();
    }

    public static void checkTell() {
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("请输入您的电话号码：");
            String phone = sc.next();
            // 判断电话号码的格式是否正确
            if (phone.matches("0\d{2,6}-?\d{5,20}")) {
                System.out.println("电话号码格式正确，注册完成！");
                break;
            } else {
                System.out.println("格式错误，请重新输入~~~");
            }
        }
    }

    public static void checkEmail() {
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("请输入您的注册邮箱：");
            String phone = sc.next();
            // 判断邮箱的格式是否正确
            if (phone.matches("\w{1,30}@[a-zA-Z0-9]{2,20}(\.[a-zA-Z0-9]{2,20}){1,2}")) {
                System.out.println("邮箱格式正确，注册完成！");
                break;
            } else {
                System.out.println("格式错误，请重新输入~~~");
            }
        }
    }

    public static void checkPhone() {
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("请输入您的手机号码：");
            String phone = sc.next();
            // 判断手机号码的格式是否正确
            if (phone.matches("1[3-9]\d{9}")) {
                System.out.println("手机号码格式正确，注册完成！");
                break;
            } else {
                System.out.println("格式错误，请重新输入~~~");
            }
        }
    }
}

3. 正则表达式在字符串方法中的使用

/** 正则表达式在方法中的应用。
 * public String[] split(String regex) --按照正则表达式匹配的内容进行分割字符串，返回一个字符串数组
 * public String replaceAll(String regex, String newStr) --按照正则表达式匹配的内容进行替换
 */
public class RegexDemo1 {
    public static void main(String[] args) {
        String names = "刘备 adjoajd 张飞 ajdiajd 关羽 aafjaijnoa";
        String[] arrs = names.split("\w+");
        for (int i = 0; i < arrs.length; i++) {
            System.out.println(arrs[i]);
        }
        String names2 = names.replaceAll("\w+", " ");
        System.out.println(names2);
    }
}

4. 正则表达式爬取信息

四、Arrays 类

1. Arrays 类概述，常用功能演示

• 数组操作工具类，专门用于操作数组元素的。

Arrays 类的常用 API

2. Arrays 类对于 Comparator 比较器的支持

Arrays 类的排序方法

自定义排序规则

• 设置 Comparator 接口对应的比较器对象，来定制比较规则。
• 如果认为左边数据 大于 右边数据 返回正整数
• 如果认为左边数据 小于 右边数据 返回负整数
• 如果认为左边数据 等于 右边数据 返回 0

五、常见算法

1. 冒泡排序

冒泡排序的思想

• 每次从数组中找出最大值放在数组的后面去。

实现冒泡排序的关键步骤分析

• 确定总共需要做几轮：数组的长度 -1.
• 每轮比较几次:
• 当前位置大于后一个位置则交换数据

2. 选择排序

选择排序的思想

• 每轮选择当前位置，开始找出后面的较小值与该位置交换

选择排序的关键

• 确定总共需要选择几轮：数组的长度 -1.
• 控制每轮从以前位置为基准，与后面元素选择几次。

/** 使用选择排序的方法对数组进行排序 */
public class Test1 {
    public static void main(String[] args) {
        // 1. 定义数组
        int[] arr = {5, 3, 6, 8}; // 0 1 2 3
        // 2. 定义一个循环控制选择几轮：arr.length - 1
        for (int i = 0; i < arr.length - 1; i++) {
            // 3. 定义内部循环：控制选择几次
            for (int j = i + 1; j < arr.length; j++) {
                // 当前位置：arr[i]
                // 如果有比当前位置数据更小，则交换
                if (arr[i] > arr[j]) {
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

3. 二分查找

• 二分查询性能好，二分查找的前提是必须是排好序的数据。
• 二分查找相当于每次去掉一半的查找范围

结论：二分查找正常的检索条件应该是开始位置 min <= 结束位置 max

• 数组的二分查找的实现步骤是什么样的
  • 定义变量记录左边和右边位置。
  • 使用 while 循环控制查询（条件是左边位置<=右边位置）
  • 循环内部获取中间元素索引
  • 判断当前要找的元素如果大于中间元素，左边位置=中间索 +1
  • 判断当前要找的元素如果小于中间元素，右边位置=中间索 - 1
  • 判断当前要找的元素如果等于中间元素，返回当前中间元素索引。

六、Lambda 表达式

1. Lambda 概述

Lambda 表达式是 JDK 8 开始后的一种新语法形式。

作用：简化匿名内部类的代码写法。

Lambda 表达式的简化格式

(匿名内部类被重写方法的形参列表) -> {
    被重写方法的方法体代码。
}

注：-> 是语法形式，无实际含义

注意：Lambda 表达式只能简化函数式接口的匿名内部类的写法形式

函数式接口：首先必须是接口、其次接口中有且仅有一个抽象方法的形式

2. Lambda 表达式的省略规则

• Lambda 表达式的省略写法（进一步在 Lambda 表达式的基础上继续简化）
• 参数类型可以省略不写。
• 如果只有一个参数，参数类型可以省略，同时 () 也可以省略。
• 如果 Lambda 表达式的方法体代码只有一行代码。可以省略大括号不写，同时要省略分号！
• 如果 Lambda 表达式的方法体代码只有一行代码。可以省略大括号不写。此时，如果这行代码是 return 语句，必须省略 return 不写，同时也必须省略";"不写

public class LambdaDemo1 {
    public static void main(String[] args) {
        // 使用 Lambda 的标准格式简化匿名内部类的代码形式
        // Lambda 只能简化接口中只有一个抽象方法的匿名内部类形式
        // Swimming s1 = new Swimming() {
        //     @Override
        //     public void swim() {
        //         System.out.println("老师游泳贼快~~~");
        //     }
        // };
        // go(s1);
        //go(() ->System.out.println("老师游泳贼快~~~"));
        go(() -> System.out.println("老师游泳贼快~~~")); //最终简化形式
    }

    public static void go(Swimming s) {
        System.out.println("开始~~~");
        s.swim();
        System.out.println("结束！！！");
    }
}

@FunctionalInterface
interface Swimming {
    void swim();
}

public class LambdaDemo2 {
    public static void main(String[] args) {
        Integer[] ages = {34, 12, 42, 23};
        /**
         * 参数一：被排序的数组，必须是引用类型的元素
         * 参数二：匿名内部类对象，代表了一个比较器对象
         */
        // Arrays.sort(ages, new Comparator() {
        //     @Override
        //     public int compare(Integer o1, Integer o2) {
        //         return o1 - o2;//升序
        //     }
        // });
        // Arrays.sort(ages, (o1, o2) -> {
        //     return o1 - o2;//升序
        // });
        Arrays.sort(ages, (o1, o2) -> o1 - o2); //最终简化形式
        System.out.println(Arrays.toString(ages));
    }
}