Java中利用正则表达式和java.time API验证时间区间字符串格式

本文详细介绍了在java中如何高效地验证包含多个时间区间的字符串格式。首先，利用正则表达式对字符串进行初步的结构性校验，确保其符合预期的模式。随后，结合java.time.localtime api对每个时间点进行精确解析，并进一步验证时间区间的逻辑正确性，例如起始时间早于结束时间。

在Java开发中，经常会遇到需要验证特定格式字符串的场景。例如，一个字符串可能包含由逗号分隔的多个时间区间，每个区间由一个起始时间和结束时间组成，格式为HH:MM-HH:MM。本文将深入探讨如何结合正则表达式和Java 8引入的java.time API，对这类复杂的时间区间字符串进行全面且健壮的格式验证。

1. 初步结构性验证：正则表达式

首先，我们需要对整个字符串进行初步的结构性校验。这可以通过正则表达式来完成，以确保字符串符合HH:MM-HH:MM,HH:MM-HH:MM,…的基本模式。

1.1 错误的尝试与分析

一些开发者可能会尝试使用类似 ^[0-9:0-9-0-9:0-9,]+$ 的正则表达式。然而，这种模式过于宽泛，它会匹配任何包含数字、冒号、连字符和逗号的组合，而无法保证HH:MM的精确结构，也无法防止逗号出现在字符串末尾等无效情况。

1.2 正确的正则表达式

一个更精确的正则表达式是：^(?:(?:d{2}:d{2}-d{2}:d{2})(?:,(?!$))?)*$。我们来解析这个正则表达式的各个部分：

^：匹配字符串的开始。$：匹配字符串的结束。d{2}：匹配任意两位数字（00-99），用于表示小时和分钟。:：匹配冒号分隔符。-：匹配连字符分隔符（需要转义）。d{2}:d{2}-d{2}:d{2}：这部分匹配一个完整的时间区间，例如 09:00-10:00。(?:…)：这是一个非捕获组，用于将多个模式组合在一起而不创建额外的捕获组。(?:,(?!$))?：这部分匹配一个逗号，但有一个重要的负向前瞻断言 (?!$)。它确保逗号后面不能是字符串的结尾，从而避免了像 09:00-10:00, 这样的无效字符串。*：表示前面的整个模式（一个时间区间加上可选的逗号）可以重复零次或多次。

在Java中，当使用 String#matches(String regex) 方法时，它会自动在内部将正则表达式包裹在 ^ 和 $ 中，所以通常我们不需要显式地添加它们。

立即学习“Java免费学习笔记（深入）”；

import java.util.regex.Pattern;public class RegexValidation {    public static boolean isValidTimeIntervalStringFormat(String strTimeRanges) {        // 正则表达式用于验证整体结构        // String#matches 方法会自动处理 ^ 和 $        String regex = "(?:(?:d{2}:d{2}-d{2}:d{2})(?:,(?!$))?)*";        return strTimeRanges.matches(regex);    }    public static void main(String[] args) {        System.out.println("09:00-10:00,12:00-14:30,16:00-18:00 -> " + isValidTimeIntervalStringFormat("09:00-10:00,12:00-14:30,16:00-18:00")); // true        System.out.println("09:00-10:00 -> " + isValidTimeIntervalStringFormat("09:00-10:00")); // true        System.out.println("09:00 10:00 -> " + isValidTimeIntervalStringFormat("09:00 10:00")); // false (空格)        System.out.println("09:00-10:00, -> " + isValidTimeIntervalStringFormat("09:00-10:00,")); // false (末尾逗号)        System.out.println("99:99-99:99 -> " + isValidTimeIntervalStringFormat("99:99-99:99")); // true (结构正确，但时间无效)    }}

请注意，虽然 99:99-99:99 通过了上述正则表达式的验证，因为它在结构上是正确的，但它并非一个有效的时间。这就引出了下一步的验证。

2. 深入时间语义验证：使用 java.time.LocalTime

正则表达式只能验证字符串的语法结构，无法判断其语义上的有效性。例如，99:99 结构上是 HH:MM，但并非一个实际存在的时间；10:00-09:00 结构正确，但逻辑上起始时间晚于结束时间。为了解决这些问题，我们需要借助 java.time.LocalTime API。

疯狂翻译师App

支持屏幕、图片、视频字幕、文档、漫画等多种翻译，准确率高，操作简单。

104 查看详情

2.1 验证单个时间点的有效性

java.time.LocalTime 提供了一个强大的 parse() 方法，可以根据ISO 8601标准（默认支持HH:MM和HH:MM:SS等格式）将字符串解析为时间对象。如果字符串无法解析为有效时间，它会抛出 DateTimeParseException。

我们可以将通过正则表达式初筛的字符串，按逗号和连字符进行分割，然后逐一解析每个时间点。

import java.time.LocalTime;import java.time.format.DateTimeParseException;public class TimeParserValidation {    public static boolean hasCorrectFormat(String strTimeRanges) {        // 1. 初步正则表达式验证        if (!strTimeRanges.matches("(?:(?:d{2}:d{2}-d{2}:d{2})(?:,(?!$))?)*")) {            return false;        }        // 2. 分割并验证每个时间点的有效性        // 注意：这里将所有时间点（起始和结束）都提取出来进行验证        String[] times = strTimeRanges.split("[-,]"); // 按逗号或连字符分割        for (String time : times) {            try {                LocalTime.parse(time); // 尝试解析时间            } catch (DateTimeParseException e) {                return false; // 解析失败，说明时间格式不正确或值无效            }        }        return true; // 所有时间点都有效    }    public static void main(String[] args) {        System.out.println("09:00-10:00,12:00-14:30,16:00-18:00 -> " + hasCorrectFormat("09:00-10:00,12:00-14:30,16:00-18:00")); // true        System.out.println("09:00-10:00,12:00-1:30,16:00-18:00 -> " + hasCorrectFormat("09:00-10:00,12:00-1:30,16:00-18:00")); // false (1:30 非 HH:MM)        System.out.println("09:00-10:00,99:99-18:00 -> " + hasCorrectFormat("09:00-10:00,99:99-18:00")); // false (99:99 非有效时间)        System.out.println("09:00-10:00 -> " + hasCorrectFormat("09:00-10:00")); // true    }}

2.2 验证时间区间的逻辑顺序

除了验证单个时间点的有效性，我们通常还需要确保每个时间区间内，起始时间早于或等于结束时间。

import java.time.LocalTime;import java.time.format.DateTimeParseException;public class FullTimeRangeValidation {    public static boolean hasCorrectFormatAndRanges(String strTimeRanges) {        // 1. 初步正则表达式验证        if (!strTimeRanges.matches("(?:(?:d{2}:d{2}-d{2}:d{2})(?:,(?!$))?)*")) {            return false;        }        // 2. 分割时间区间并验证其内部逻辑        String[] timeRanges = strTimeRanges.split(","); // 按逗号分割，获取每个时间区间字符串        for (String timeRange : timeRanges) {            String[] times = timeRange.split("-"); // 按连字符分割，获取起始时间和结束时间            try {                LocalTime startTime = LocalTime.parse(times[0]);                LocalTime endTime = LocalTime.parse(times[1]);                // 验证结束时间是否在起始时间之后                if (endTime.isBefore(startTime)) {                    return false; // 结束时间早于起始时间，逻辑错误                }            } catch (DateTimeParseException e) {                // 如果在这一步才捕获到DateTimeParseException，说明前面的正则表达式不够严谨                // 但作为二次校验，捕获并返回false也是一种安全措施                return false;            }        }        return true; // 所有验证通过    }    public static void main(String[] args) {        System.out.println("09:00-10:00,12:00-14:30,16:00-18:00 -> " + hasCorrectFormatAndRanges("09:00-10:00,12:00-14:30,16:00-18:00")); // true        System.out.println("09:00-10:00,12:00-1:30,16:00-18:00 -> " + hasCorrectFormatAndRanges("09:00-10:00,12:00-1:30,16:00-18:00")); // false (1:30 非 HH:MM)        System.out.println("10:00-09:00,12:00-14:30,16:00-18:00 -> " + hasCorrectFormatAndRanges("10:00-09:00,12:00-14:30,16:00-18:00")); // false (10:00-09:00 逻辑错误)        System.out.println("09:00-09:00 -> " + hasCorrectFormatAndRanges("09:00-09:00")); // true (开始等于结束是允许的)    }}

3. 完整示例与注意事项

将上述两种验证方式结合起来，可以创建一个全面且健壮的验证方法。

import java.time.LocalTime;import java.time.format.DateTimeParseException;public class TimeIntervalValidator {    /**     * 验证时间区间字符串是否符合正确的格式和逻辑。     * 字符串格式示例: "09:00-10:00,12:00-14:30,16:00-18:00"     *     * @param strTimeRanges 待验证的时间区间字符串     * @return 如果格式和逻辑都正确，则返回 true；否则返回 false。     */    public static boolean validateTimeIntervalString(String strTimeRanges) {        // 1. 使用正则表达式进行初步的结构性验证        // 确保字符串符合 HH:MM-HH:MM 的模式，且逗号不出现在末尾        String regex = "(?:(?:d{2}:d{2}-d{2}:d{2})(?:,(?!$))?)*";        if (!strTimeRanges.matches(regex)) {            return false;        }        // 如果字符串为空，则认为格式正确（没有时间区间）        if (strTimeRanges.isEmpty()) {            return true;        }        // 2. 分割时间区间，并使用 java.time.LocalTime 进行语义和逻辑验证        String[] timeRanges = strTimeRanges.split(",");        for (String timeRange : timeRanges) {            String[] times = timeRange.split("-");            // 每个区间必须包含两个时间点（起始和结束）            if (times.length != 2) {                return false;            }            try {                LocalTime startTime = LocalTime.parse(times[0]);                LocalTime endTime = LocalTime.parse(times[1]);                // 验证时间区间的逻辑：结束时间必须在起始时间之后或等于起始时间                if (endTime.isBefore(startTime)) {                    return false;                }            } catch (DateTimeParseException e) {                // 如果LocalTime.parse失败，说明时间字符串本身无效（如"25:00"或"09:99"）                return false;            }        }        return true; // 所有验证通过    }    public static void main(String[] args) {        // 测试用例        System.out.println("--- 验证结果 ---");        System.out.println("09:00-10:00,12:00-14:30,16:00-18:00 -> " + validateTimeIntervalString("09:00-10:00,12:00-14:30,16:00-18:00")); // true        System.out.println("09:00-10:00 -> " + validateTimeIntervalString("09:00-10:00")); // true        System.out.println(" -> " + validateTimeIntervalString("")); // true (空字符串，无时间区间)        System.out.println("09:00 10:00 -> " + validateTimeIntervalString("09:00 10:00")); // false (空格，不符合正则)        System.out.println("09:00-10:00, -> " + validateTimeIntervalString("09:00-10:00,")); // false (末尾逗号，不符合正则)        System.out.println("09:00-10:00,12:00-1:30,16:00-18:00 -> " + validateTimeIntervalString("09:00-10:00,12:00-1:30,16:00-18:00")); // false (1:30 非 HH:MM，LocalTime解析失败)        System.out.println("10:00-09:00,12:00-14:30,16:00-18:00 -> " + validateTimeIntervalString("10:00-09:00,12:00-14:30,16:00-18:00")); // false (10:00-09:00 逻辑错误)        System.out.println("09:00-10:00-12:00-14:30,16:00-18:00 -> " + validateTimeIntervalString("09:00-10:00-12:00-14:30,16:00-18:00")); // false (连字符过多，不符合正则)        System.out.println("25:00-26:00 -> " + validateTimeIntervalString("25:00-26:00")); // false (LocalTime解析失败)        System.out.println("09:60-10:00 -> " + validateTimeIntervalString("09:60-10:00")); // false (LocalTime解析失败)    }}

注意事项

分阶段验证： 采用正则表达式进行初步的结构性验证，再使用 java.time API进行详细的语义和逻辑验证，这种分阶段的方法既高效又健壮。正则表达式可以快速排除大量不符合基本结构的字符串，避免不必要的 LocalTime 解析开销。String#matches() 的特性： String#matches(String regex) 方法在内部会隐式地将正则表达式锚定到字符串的开头和结尾（即自动添加 ^ 和 $），因此在编写 regex 参数时通常不需要手动添加它们。异常处理： LocalTime.parse() 方法在遇到无法解析的字符串时会抛出 DateTimeParseException。正确捕获和处理此异常是确保程序健壮性的关键。扩展性： 如果需要处理更复杂的场景，例如检查时间区间是否重叠、是否在特定日期范围内、是否跨越午夜等，可以在 LocalTime 对象上进行进一步的逻辑判断。例如，判断重叠需要将所有区间解析为 LocalTime 对，然后进行排序和比较。

总结

通过结合正则表达式对时间区间字符串进行初步的结构性校验，以及利用 java.time.LocalTime API对每个时间点进行精确解析和逻辑顺序验证，我们可以构建一个强大而灵活的验证机制。这种两阶段的验证方法不仅提高了验证的准确性，也使得代码更易于理解和维护，是处理复杂时间字符串验证的推荐实践。

以上就是Java中利用正则表达式和java.time API验证时间区间字符串格式的详细内容，更多请关注创想鸟其它相关文章！