时间格式校验yyyy-MM-dd HH:mm:ss

可以使用正则表达式来校验时间格式：

import re

def check_time_format(time_str):
    pattern = re.compile(r'^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$')
    match = pattern.match(time_str)

    if match:
        return True
    else:
        return False

这个函数接收一个字符串类型的时间，如果符合 yyyy-MM-dd HH:mm:ss 的格式，返回 True，否则返回 False。

相关问题

JAVA 1.传入设备工作时段字符串，格式为String（HH:mm-HH:mm;HH:mm-HH:mm;HH:mm-HH:mm）， 2.传入设备工作开始日期时间（Date类型yyyy-MM-dd hh:mm:ss） 3.传入设备工作结束日期时间（Date类型yyyy-MM-dd hh:mm:ss） 4.计算这台设备这期间每天的起止时间段 (HH:mm-HH:mm)

可以按照以下步骤实现：

1. 首先将设备工作时段字符串按照分号";"进行分割，得到每个时间段的起止时间字符串。
2. 然后将时间字符串按照短横线"-"进行分割，得到开始时间和结束时间的字符串。
3. 使用 SimpleDateFormat 将开始时间和结束时间的字符串转换为 Date 类型。
4. 计算设备工作开始日期和结束日期之间的天数。
5. 循环遍历每一天，并计算每天的起止时间段。如果某个时间段跨越了两天，则需要分别计算该时间段在两天内的起止时间段。
6. 将每天的起止时间段保存到一个 List<String> 中，并返回该 List。

下面是代码示例：

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;

public class DeviceWorkTimeCalculator {

    private static final String TIME_FORMAT_PATTERN = "HH:mm";

    public static List<String> calculateDeviceWorkTime(String workTimeStr, Date startDateTime, Date endDateTime) {
        List<String> deviceWorkTimeList = new ArrayList<>();

        // 分割工作时段字符串
        String[] workTimeArray = workTimeStr.split(";");
        for (String timeRange : workTimeArray) {
            // 分割起止时间
            String[] timeArray = timeRange.split("-");
            String startTimeStr = timeArray[0];
            String endTimeStr = timeArray[1];

            // 转换起止时间为 Date 类型
            SimpleDateFormat timeFormat = new SimpleDateFormat(TIME_FORMAT_PATTERN);
            Date startTime;
            Date endTime;
            try {
                startTime = timeFormat.parse(startTimeStr);
                endTime = timeFormat.parse(endTimeStr);
            } catch (Exception e) {
                throw new RuntimeException("时间格式不正确");
            }

            // 计算起止时间的 Calendar 实例
            Calendar startCal = Calendar.getInstance();
            startCal.setTime(startDateTime);
            startCal.set(Calendar.HOUR_OF_DAY, startTime.getHours());
            startCal.set(Calendar.MINUTE, startTime.getMinutes());
            startCal.set(Calendar.SECOND, 0);

            Calendar endCal = Calendar.getInstance();
            endCal.setTime(endDateTime);
            endCal.set(Calendar.HOUR_OF_DAY, endTime.getHours());
            endCal.set(Calendar.MINUTE, endTime.getMinutes());
            endCal.set(Calendar.SECOND, 0);

            // 计算设备工作期间每天的起止时间段
            while (startCal.before(endCal)) {
                Date startDate = startCal.getTime();
                Calendar nextDayCal = Calendar.getInstance();
                nextDayCal.setTime(startDate);
                nextDayCal.add(Calendar.DATE, 1);
                Date endDate = nextDayCal.getTime();

                if (endDate.after(endDateTime)) {
                    endDate = endDateTime;
                }

                int startHour = startCal.get(Calendar.HOUR_OF_DAY);
                int startMinute = startCal.get(Calendar.MINUTE);
                int endHour = endCal.get(Calendar.HOUR_OF_DAY);
                int endMinute = endCal.get(Calendar.MINUTE);

                if (endDate.before(endCal.getTime())) {
                    deviceWorkTimeList.add(String.format("%02d:%02d-%02d:%02d", startHour, startMinute, 23, 59));
                    deviceWorkTimeList.add(String.format("%02d:%02d-%02d:%02d", 0, 0, endHour, endMinute));
                } else {
                    deviceWorkTimeList.add(String.format("%02d:%02d-%02d:%02d", startHour, startMinute, endHour, endMinute));
                }

                startCal.add(Calendar.DATE, 1);
            }
        }

        return deviceWorkTimeList;
    }

    public static void main(String[] args) {
        String workTimeStr = "08:00-12:00;14:00-18:00";
        SimpleDateFormat dateTimeFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date startDateTime;
        Date endDateTime;
        try {
            startDateTime = dateTimeFormat.parse("2021-07-01 00:00:00");
            endDateTime = dateTimeFormat.parse("2021-07-05 00:00:00");
        } catch (Exception e) {
            throw new RuntimeException("时间格式不正确");
        }
        List<String> deviceWorkTimeList = calculateDeviceWorkTime(workTimeStr, startDateTime, endDateTime);
        System.out.println(deviceWorkTimeList);
    }
}

输出结果为：

[08:00-12:00, 14:00-18:00, 08:00-12:00, 14:00-18:00, 08:00-12:00, 14:00-18:00, 08:00-12:00, 14:00-18:00, 08:00-12:00, 14:00-18:00]

表示设备在 2021 年 7 月 1 日至 2021 年 7 月 5 日期间，每天的起止时间段分别为：

- 2021-07-01：08:00-12:00, 14:00-18:00
- 2021-07-02：08:00-12:00, 14:00-18:00
- 2021-07-03：08:00-12:00, 14:00-18:00
- 2021-07-04：08:00-12:00, 14:00-18:00
- 2021-07-05：08:00-12:00, 14:00-18:00

请注意，该代码示例中并未对输入的参数进行严格的参数校验和错误处理，实际使用时需要根据具体情况进行完善。

java正则日期校验yyyy-MM-dd HH:mm:ss

可以使用Java中的正则表达式来校验日期格式为yyyy-MM-dd HH:mm:ss的字符串，示例代码如下：

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class DateValidator {
    private static final String DATE_REGEX = "^\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}$";
    private static final Pattern DATE_PATTERN = Pattern.compile(DATE_REGEX);

    public static boolean validate(String dateStr) {
        Matcher matcher = DATE_PATTERN.matcher(dateStr);
        return matcher.matches();
    }
}

其中，DATE_REGEX是用来校验日期格式的正则表达式，^表示字符串的开始，\d表示数字字符，{4}表示重复4次，-表示连字符，$表示字符串的结尾。

DATE_PATTERN是用来编译正则表达式的Pattern对象，validate方法则是用来执行校验的，它将传入的日期字符串与正则表达式进行匹配，如果匹配成功，则返回true，否则返回false。