Java 黑马程序员学习笔记（进阶篇6）

常用的 API

1. 正则表达式

(1) 题目：贪婪爬取和非贪婪爬取

① 贪婪爬取：爬取数据的时候尽可能的多获取数据
② 非贪婪爬取：爬取数据的时候尽可能的少获取数据
③ Java中默认的是贪婪爬取
④ + 后面加上 ? 可以转变为非贪婪爬取

(2) 捕获分组

捕获分组通过 (...)将部分正则表达式包裹，会保存该组的匹配结果；后续可通过 \\n（n为分组编号，从1开始）反向引用这组结果，实现 “重复使用已匹配的内容”。

需求 1：单字符首尾一致（如 a123a、b456b）

正则表达式：(. ).+\\1

① 逻辑分解：

• (. )：第1个捕获组，匹配任意一个字符（.匹配任意字符，括号捕获该字符）。
• .+：匹配中间任意长度的字符（1个或多个）。
• \\1：反向引用第1个捕获组的内容，要求结尾字符必须和开头捕获的单个字符一致。

② 示例验证：

• a123a → 开头捕获a，结尾a → 匹配成功。
• a123b → 开头a，结尾b → 匹配失败。

需求 2：多字符首尾一致（如 abc123abc、&|@abc&|@）

正则表达式：(.+).+\\1

① 逻辑分解：

• (.+)：第1个捕获组，+表示 “1个或多个字符”，即匹配任意长度的开头子串（至少1个字符）。
• .+：匹配中间任意长度字符。
• \\1：反向引用第1个捕获组的内容，要求结尾子串必须和开头捕获的多字符子串完全一致。

② 示例验证：

• abc123abc → 开头捕获abc，结尾abc → 匹配成功。
• abc123abd → 开头abc，结尾abd → 匹配失败。

需求 3 ：首尾多字符（内部字符一致），且中间至少有 1 个字符，且开头内部至少重复 1 次

正则表达式：((.)\\2+).+\\1

① 最内层：(.)（第 2 个捕获组）

• (.)：( 表示创建捕获组，. 匹配任意单个字符（比如 a、b、& 等）。
• 这部分的作用：捕获一个 “基础字符”，后续会重复使用这个字符。
• 编号：因为是第 2 个出现的左括号（第一个左括号是外层的 (），所以是第 2 组，后续用 \\2 引用。

② 中间层：\\2+

• \\2：反向引用第 2 组捕获的 “基础字符”（比如第 2 组捕获了 a，\\2 就代表 a）。
• +：量词，表示 “至少出现 1 次”（和 * 不同，* 允许 0 次，+ 必须 1 次及以上）。
• 组合起来：\\2+ 表示 “基础字符至少重复 1 次”（比如基础字符是 a，就匹配 aa、aaa、aaaa 等）。

③ 外层分组：((.)\\2+)（第 1 个捕获组）

• 把 (.) 和 \\2+ 整体包裹，形成第 1 组。
• 作用：捕获 “由同一个基础字符重复组成的子串”，且这个子串长度至少 2 个字符（因为基础字符 1 个 + 至少重复 1 次 = 2 个及以上）。
  例如：
  • 基础字符 a + \\2+（a 重复 2 次）→ 第 1 组捕获 aaa；
  • 基础字符 & + \\2+（& 重复 1 次）→ 第 1 组捕获 &&。

④ 中间内容：.+

• . 匹配任意字符，+ 表示 “至少 1 次”。
• 作用：要求开头和结尾的子串之间，必须有至少 1 个字符（不能是空的）。

⑤ 结尾：\\1

• 反向引用第 1 组捕获的内容（即 “由同一个基础字符重复组成的子串”）。
• 作用：要求字符串结尾的子串，必须和开头的子串完全一致。

需求 4：“口吃” 字符去重

将包含重复字符的字符串（如 我要学学编编编编编程程程程程程），替换为单个重复字符，最终得到 我要学编编程。

public class RegexDemo4 {
    public static void main(String[] args) {
        // 原始字符串：包含重复的“学”“编”“程”
        String str = "我要学学编编编编编程程程程程程";
        // 正则：匹配“单个字符 + 至少1个相同重复字符”
        String regex = "(.)\\1+";
        // 替换：用“基准字符（$1）”替换“重复字符组”
        String result = str.replaceAll(regex, "$1");
        System.out.println(result); // 输出：我要学编编程
    }
}

关键逻辑 1：拆解 (.)\\1+

① 处理 “学学”：

• (.) 捕获第一个 “学”（组 1 存 “学”）；
• \\1+ 匹配第二个 “学”（满足 “至少 1 次”）；
• 匹配到 “学学”，替换成 “$1”（即 “学”）。

② 处理 “编编编”：

• (.) 捕获第一个 “编”（组 1 存 “编”）；
• \\1+ 匹配后面的 “编编”（至少 1 次）；
• 匹配到 “编编编”，替换成 “编”。

③ 处理 “程”：

• 因为 “程” 没有重复（\\1+ 要求至少 1 次重复，不满足），所以不匹配正则，保留原样。

④ 最终结果就是 “学编程”。

关键逻辑 2：$1 的作用

① $1 是正则表达式替换操作中的反向引用语法，用于在「替换字符串」中，引用正则里第一个捕获组（由圆括号 () 包裹的部分）所匹配到的具体内容。

② 核心作用：在字符串替换时，用「捕获组匹配到的内容」替换「整个正则匹配到的重复 / 复杂内容」，实现 “提取关键部分，简化重复内容” 的效果。

③ 举例理解：

比如要把字符串 "aaaabbbcc" 中连续重复的字符压缩成单个：

(1) 正则表达式：(.)\\1+

• (.) 是第一个捕获组，负责 “捕获单个任意字符”（比如匹配 "aaaa" 时，捕获组会抓到 'a'）；
• \\1+ 表示 “必须跟着至少一个和捕获组内容相同的字符”（即重复的 'a'）。

(2) 替换字符串："$1"
当正则匹配到 "aaaa" 时，$1 会引用第一个捕获组抓到的 'a'，于是用 'a' 替换整个 "aaaa"；同理，"bbb" 会被 'b' 替换，"cc" 会被 'c' 替换。

(3) 最终效果："aaaabbbcc" → "abc"。

关键总结：

• (.)：抓一个 “基准字符” 并记住（存到组 1）；
• \\1+：找 “和基准字符相同的、至少 1 个的后续字符”，凑成 “重复序列”；
• replaceAll(..., "$1")：用 “基准字符” 替换整个 “重复序列”，实现 “去重”。

2. Date

JDK 8 之前的时间处理：在 Java 8 之前，日期和时间的处理主要依赖 Date、SimpleDateFormat、Calendar 三个核心类（但存在可操作性弱、线程不安全等局限性，因此 JDK 8 后被新的 java.time 包替代）。

java.util.Date 类

package demo2;

import java.util.Date;
import java.util.Random;

public class test4 {
    public static void main(String[] args) {
        Random r = new Random();
        Date d1 = new Date(Math.abs(r.nextInt()));
        Date d2 = new Date(Math.abs(r.nextInt()));

        long time1 = d1.getTime();
        long time2 = d2.getTime();

        if (time1 > time2) {
            System.out.println("第一个时间在前面，第二个时间在后面");
        } else if (time1 < time2) {
            System.out.println("第二个时间在前面，第二个时间在后面");
        } else {
            System.out.println("两个时间一样");
        }
    }

关键逻辑 1：Date d1 = new Date(参数);

① Date 类的本质是 “封装一个具体的时间点”，而它最核心的构造函数就是 Date(long date)—— 接收一个 long 类型的数字（称为 “时间戳”），并以此创建对应的时间对象。

② 时间戳的定义：指 从 1970 年 1 月 1 日 00:00:00 GMT（格林威治标准时间）开始，到某个时间点的 “毫秒数”。
比如：

• 时间戳 0 → 对应 1970-01-01 00:00:00 GMT；
• 时间戳 1000 → 对应 1970-01-01 00:00:01 GMT（比基准时间多 1 秒，1 秒 = 1000 毫秒）；
• 时间戳越大，代表的时间越靠后（越 “新”）。

• 代码中 new Date(参数) 的作用：
  用传入的 “时间戳” 创建一个 Date 对象，这个对象就代表了该时间戳对应的 “具体时间点”。
  比如 d1 就是一个封装了 “参数对应时间戳” 的时间对象，d2 同理。

关键逻辑 2：long time1 = d1.getTime();

① Date 类的 getTime() 方法是上述构造函数的 反向操作：

② 作用：返回当前 Date 对象所封装的 时间戳（毫秒数）。
简单说：

• 用 new Date(时间戳) 可以把 “数字” 变成 “时间对象”；
• 用 getTime() 可以把 “时间对象” 变回 “数字（时间戳）”。

SimpleDateFormat 类

① 核心作用：实现 Date（日期对象） 与 String（字符串） 的双向转换：

• 格式化：将 Date 转换为自定义格式的字符串；
• 解析：将自定义格式的字符串转换为 Date。

② 构造方法

③ 常用方法

④ 常用符号

⑤ 练习：秒杀活动时间范围校验程序

题目描述：某平台开展限时秒杀活动，活动时间为 2023年11月11日 0:0:0 至 2023年11月11日 0:10:0。请编写程序，判断某笔订单的时间（2023年11月11日 0:01:00）是否在秒杀活动的有效时间范围内，若在范围内则提示 “参加秒杀活动成功”，否则提示 “参加秒杀活动失败”。

package demo2;

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

public class test8 {
    public static void main(String[] args) throws ParseException {
        String startStr = "2023年11月11日 0:0:0";
        String endStr = "2023年11月11日 0:10:0";
        String orderStr = "2023年11月11日 0:01:00";

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        Date startDate = sdf.parse(startStr);
        Date endDate = sdf.parse(endStr);
        Date orderDate = sdf.parse(orderStr);

        long startTime = startDate.getTime();
        long endTime = endDate.getTime();
        long orderTime = orderDate.getTime();

        if (orderTime >= startTime && orderTime <= endTime) {
            System.out.println("参加秒杀活动成功");
        } else {
            System.out.println("参加秒杀活动失败");
        }
    }
}

Calendar 类

① 概论

• Calendar 是代表系统当前时间的日历对象，可单独修改、获取 “年、月、日、时、分、秒” 等时间字段。
• 关键细节：Calendar 是抽象类，不能直接通过 new 创建对象，需通过静态方法获取实例。

② 获取 Calendar 实例的方法

通过静态方法 getInstance() 获取 “当前系统时间” 的日历对象：

Calendar cal = Calendar.getInstance();

③ 常用方法及功能

④ 常用字段常量（配合 get/set/add 使用）

Calendar 定义了常量表示 “年、月、日” 等字段，常用的有：

• Calendar.YEAR：年
• Calendar.MONTH：月（注意：月份从 0 开始，0=1 月，11=12 月）
• Calendar.DAY_OF_MONTH：月中的日期
• Calendar.HOUR_OF_DAY：24 小时制的 “时”
• Calendar.MINUTE：分
• Calendar.SECOND：秒