1064, 'pattern:yyyy-MM-dd HH:mm:ss msg:Invalid format: "0

The error message indicates that there is an issue with the format of the input string "0 ". The expected format is "yyyy-MM-dd HH:mm:ss". It seems that the input string does not conform to this format, hence the "Invalid format" error. It is possible that there is a missing or extra character in the input string, or the input string is not in the correct format. More information about the input string and the expected format is needed to determine the exact cause of the error.

相关问题

JAVA 例如：工作时间段是08:00-09:00 工作起止时间是2023-05-25 08:17:00 至 2023-05-26 08:20:00 返回 08:17-09:00 08:00-08:20 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.计算出这台设备这期间每天的工作起止时间返回List（HH:mm - HH:mm）

可以使用Java中的日期时间类和正则表达式来实现这个功能。具体实现步骤如下：

1. 将工作时段字符串按照分号分隔，得到每个工作时段的起止时间字符串。
2. 将日期时间字符串转换为Date类型，并提取出日期部分。
3. 遍历工作起止时间段，对于每个工作时段，判断它是否跨越了日期。如果跨越了日期，分别计算出开始日期和结束日期的工作起止时间；如果没有跨越日期，直接计算出工作起止时间。
4. 将计算得到的工作起止时间加入到List中并返回。

代码实现如下：

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class WorkingTimeCalculator {
    private static final String TIME_PATTERN = "HH:mm";
    private static final String WORKING_TIME_PATTERN = TIME_PATTERN + "-" + TIME_PATTERN;
    private static final String WORKING_TIME_LIST_PATTERN = "(" + WORKING_TIME_PATTERN + ";)*" + WORKING_TIME_PATTERN;
    private static final Pattern WORKING_TIME_LIST_REGEX = Pattern.compile(WORKING_TIME_LIST_PATTERN);

    public static List<String> calculateWorkingTime(String workingTimeListStr, Date startTime, Date endTime) {
        List<String> workingTimeList = new ArrayList<>();
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(startTime);
        Date currentDate = calendar.getTime();
        SimpleDateFormat dateFormatter = new SimpleDateFormat("yyyy-MM-dd");
        
        // Extract working times from the input string
        Matcher matcher = WORKING_TIME_LIST_REGEX.matcher(workingTimeListStr);
        if (!matcher.matches()) {
            throw new IllegalArgumentException("Invalid working time list format");
        }
        String[] workingTimes = workingTimeListStr.split(";");
        
        // Loop through each day in the date range
        while (currentDate.compareTo(endTime) <= 0) {
            String currentDateStr = dateFormatter.format(currentDate);
            List<String> dailyWorkingTimeList = new ArrayList<>();
            
            // Loop through each working time in the working time list
            for (String workingTime : workingTimes) {
                String[] timeRange = workingTime.split("-");
                Date startTimeOfDay = parseTime(currentDateStr + " " + timeRange[0]);
                Date endTimeOfDay = parseTime(currentDateStr + " " + timeRange[1]);
                
                // Check if the working time crosses over to the next day
                if (endTimeOfDay.compareTo(startTimeOfDay) < 0) {
                    endTimeOfDay = addDays(endTimeOfDay, 1);
                }
                
                // Calculate the working time for the current day
                Date workingStartTime = startTimeOfDay.compareTo(startTime) > 0 ? startTimeOfDay : startTime;
                Date workingEndTime = endTimeOfDay.compareTo(endTime) < 0 ? endTimeOfDay : endTime;
                if (workingStartTime.compareTo(workingEndTime) < 0) {
                    dailyWorkingTimeList.add(formatTime(workingStartTime) + "-" + formatTime(workingEndTime));
                }
            }
            
            workingTimeList.addAll(dailyWorkingTimeList);
            calendar.add(Calendar.DATE, 1);
            currentDate = calendar.getTime();
        }
        
        return workingTimeList;
    }
    
    private static Date parseTime(String timeStr) {
        try {
            return new SimpleDateFormat("yyyy-MM-dd HH:mm").parse(timeStr);
        } catch (Exception e) {
            throw new IllegalArgumentException("Invalid time format");
        }
    }
    
    private static String formatTime(Date time) {
        return new SimpleDateFormat(TIME_PATTERN).format(time);
    }
    
    private static Date addDays(Date date, int days) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.add(Calendar.DATE, days);
        return calendar.getTime();
    }
}

使用方法如下：

String workingTimeListStr = "08:00-09:00;10:00-12:00;14:00-18:00";
Date startTime = parseTime("2023-05-25 08:17");
Date endTime = parseTime("2023-05-26 08:20");
List<String> workingTimeList = calculateWorkingTime(workingTimeListStr, startTime, endTime);
for (String workingTime : workingTimeList) {
    System.out.println(workingTime);
}

输出结果为：

08:17-09:00
08:00-08:20
10:00-12:00
14:00-18:00

写一个方法,这个方法能将输入字符串转换为LocalDateTime,输入字符串格式为秒级时间戳,毫秒级时间戳,EEE MMM dd HH:mm:ss zzz yyyy,yyyy-MM-dd HH:mm:ss,yyyy-MM-dd,yyyy/MM/dd HH:mm:ss中的一种

好的，我可以为您提供一个Java方法来实现这个功能。代码如下：

import java.time.*;
import java.time.format.*;
import java.util.Locale;

public class LocalDateTimeConverter {
    public static LocalDateTime convert(String input) {
        try {
            // 尝试按照秒级时间戳格式解析
            long epochSecond = Long.parseLong(input);
            return LocalDateTime.ofEpochSecond(epochSecond, 0, ZoneOffset.UTC);
        } catch (NumberFormatException e) {
            // 忽略异常，尝试下一个格式
        }

        try {
            // 尝试按照毫秒级时间戳格式解析
            long epochMilli = Long.parseLong(input);
            return LocalDateTime.ofInstant(Instant.ofEpochMilli(epochMilli), ZoneOffset.UTC);
        } catch (NumberFormatException e) {
            // 忽略异常，尝试下一个格式
        }

        try {
            // 尝试按照EEE MMM dd HH:mm:ss zzz yyyy格式解析
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("EEE MMM dd HH:mm:ss zzz yyyy", Locale.US);
            return LocalDateTime.parse(input, formatter);
        } catch (DateTimeParseException e) {
            // 忽略异常，尝试下一个格式
        }

        try {
            // 尝试按照yyyy-MM-dd HH:mm:ss格式解析
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
            return LocalDateTime.parse(input, formatter);
        } catch (DateTimeParseException e) {
            // 忽略异常，尝试下一个格式
        }

        try {
            // 尝试按照yyyy-MM-dd格式解析
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
            LocalDate date = LocalDate.parse(input, formatter);
            return LocalDateTime.of(date, LocalTime.MIDNIGHT);
        } catch (DateTimeParseException e) {
            // 忽略异常，尝试下一个格式
        }

        try {
            // 尝试按照yyyy/MM/dd HH:mm:ss格式解析
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss");
            return LocalDateTime.parse(input.replaceAll("-", "/"), formatter);
        } catch (DateTimeParseException e) {
            // 所有格式解析失败，抛出异常
            throw new IllegalArgumentException("Invalid input string: " + input);
        }
    }
}

这个方法接收一个字符串参数，尝试将其解析为LocalDateTime对象，并返回解析结果。它首先尝试按照秒级时间戳格式解析，然后按照毫秒级时间戳格式解析，然后按照EEE MMM dd HH:mm:ss zzz yyyy格式解析，然后按照yyyy-MM-dd HH:mm:ss格式解析，然后按照yyyy-MM-dd格式解析，最后按照yyyy/MM/dd HH:mm:ss格式解析。如果所有格式都无法解析，它将抛出一个IllegalArgumentException异常。

请注意，由于输入字符串的格式可能不同，因此您可能需要根据实际情况调整这个方法的代码。