Java中利用正则表达式和java.time API验证时间区间字符串格式-java教程-PHP中文网

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。

美间AI

美间AI：让设计更简单

查看详情

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 对，然后进行排序和比较。