解析像“1h 30min”这样的时间字符串

Question

任何人都知道有一个 Java 库可以将“30min”或“2h 15min”或“2d 15h 30min”等时间字符串解析为毫秒（或某种 Duration 对象）。 Joda-Time 可以做这样的事情吗？

（我有一个丑陋的长方法来维护它进行这样的解析，并且想摆脱它/用做得更好的东西替换它。）

Answer 1

您可能需要根据自己的格式稍微调整一下，但请尝试以下操作：

PeriodFormatter formatter = new PeriodFormatterBuilder()
    .appendDays().appendSuffix("d ")
    .appendHours().appendSuffix("h ")
    .appendMinutes().appendSuffix("min")
    .toFormatter();

Period p = formatter.parsePeriod("2d 5h 30min");

请注意，如果需要，有一个 appendSuffix 接受 variants 参数使其更加灵活。

更新：Joda Time 此后添加了 Period.toStandardDuration()，然后您可以使用 getStandardSeconds()< /a> 获取 long 形式的经过时间（以秒为单位）。

如果您使用的是没有这些方法的旧版本，您仍然可以通过假设一天中的标准 24/小时、60 分钟/小时等自行计算时间戳。（在这种情况下，请利用 中的常量DateTimeConstants 类以避免需要幻数。）

Answer 2

持续时间解析现已包含在 Java 8 中。使用标准 ISO 8601 格式和 Duration.parse。

Duration d = Duration.parse("PT1H30M")

您可以转换此持续时间到总长度（以毫秒为单位）。请注意，Duration 的分辨率为纳秒，因此您可能会丢失纳秒的数据 到 毫秒。

long milliseconds = d.toMillis();

该格式与您所描述的格式略有不同，但可以轻松地从一种格式转换为另一种格式。

Answer 3

我想让日期、小时和分钟可选，这似乎可以做到这一点。请注意，appendSuffix() 调用在字符后没有空格。

使用乔达2.3。

PeriodParser parser = new PeriodFormatterBuilder()
        .appendDays().appendSuffix("d").appendSeparatorIfFieldsAfter(" ")
        .appendHours().appendSuffix("h").appendSeparatorIfFieldsAfter(" ")
        .appendMinutes().appendSuffix("min")
        .toParser();

上面的代码通过了这些测试。

@Test
public void testConvert() {
    DurationConverter c = new DurationConverter();

    Duration d;
    Duration expected;

    d = c.convert("1d");
    expected = Duration.ZERO
            .withDurationAdded(Duration.standardDays(1),1);
    assertEquals(d, expected);

    d = c.convert("1d 1h 1min");
    expected = Duration.ZERO
            .withDurationAdded(Duration.standardDays(1),1)
            .withDurationAdded(Duration.standardHours(1),1)
            .withDurationAdded(Duration.standardMinutes(1),1);
    assertEquals(d, expected);


    d = c.convert("1h 1min");
    expected = Duration.ZERO
            .withDurationAdded(Duration.standardHours(1),1)
            .withDurationAdded(Duration.standardMinutes(1),1);
    assertEquals(d, expected);

    d = c.convert("1h");
    expected = Duration.ZERO
            .withDurationAdded(Duration.standardHours(1),1);
    assertEquals(d, expected);

    d = c.convert("1min");
    expected = Duration.ZERO
            .withDurationAdded(Duration.standardMinutes(1),1);
    assertEquals(d, expected);

}

Answer 4

仅供参考，只是写了一个多小时，仅使用 java.time.*，非常容易理解并根据任何需要进行自定义；

此版本适用于以下字符串： 3d12h、2y、9m10d 等。

import java.time.Duration;
import java.time.Instant;
import java.time.Period;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.Locale;

private static final Pattern periodPattern = Pattern.compile("([0-9]+)([hdwmy])");

public static Long parsePeriod(String period){
    if(period == null) return null;
    period = period.toLowerCase(Locale.ENGLISH);
    Matcher matcher = periodPattern.matcher(period);
    Instant instant=Instant.EPOCH;
    while(matcher.find()){
        int num = Integer.parseInt(matcher.group(1));
        String typ = matcher.group(2);
        switch (typ) {
            case "h":
                instant=instant.plus(Duration.ofHours(num));
                break;
            case "d":
                instant=instant.plus(Duration.ofDays(num));
                break;
            case "w":
                instant=instant.plus(Period.ofWeeks(num));
                break;
            case "m":
                instant=instant.plus(Period.ofMonths(num));
                break;
            case "y":
                instant=instant.plus(Period.ofYears(num));
                break;
        }
    }
    return instant.toEpochMilli();
}

Answer 5

java.time

下面引用的是 主页的通知乔达时间：

请注意，从 Java SE 8 开始，用户被要求迁移到 java.time (JSR-310) - JDK 的核心部分，它将取代该项目。

使用现代日期时间 API java.time 的解决方案：

您可以将输入字符串转换为 ISO_8601#Duration 格式，然后将其解析为 java.time.Duration 作为 JSR-310 实现。

演示：

import java.time.Duration;
import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        // Test
        Stream.of(
                "30min",
                "2h 15min",
                "2d 15h 30min",
                "30sec",
                "2h 15min 10sec",
                "2day 15hour 30min",
                "2 days 15 hours 30 mins",
                "2 Days 15 Hours 30 Minutes",
                "2days 15hrs 30mins",
                "2 Hours 15 Minutes 10 Seconds"
        ).forEach(s -> System.out.println(s + " => " + toMillis(s) + "ms"));
    }

    static long toMillis(String strDuration) {
        strDuration = strDuration.toUpperCase()
                .replaceAll("\\s+", "")
                .replaceAll("DAYS?", "D")
                .replaceAll("(?:HOURS?)|(?:HRS?)", "H")
                .replaceAll("(?:MINUTES?)|(?:MINS?)", "M")
                .replaceAll("(?:SECONDS?)|(?:SECS?)", "S")
                .replaceAll("(\\d+D)", "P$1T");
        strDuration = strDuration.charAt(0) != 'P' ? "PT" + strDuration : strDuration;
        // System.out.println(strDuration);
        Duration duration = Duration.parse(strDuration);
        return duration.toMillis();
    }
}

输出：

30min => 1800000ms
2h 15min => 8100000ms
2d 15h 30min => 228600000ms
30sec => 30000ms
2h 15min 10sec => 8110000ms
2day 15hour 30min => 228600000ms
2 days 15 hours 30 mins => 228600000ms
2 Days 15 Hours 30 Minutes => 228600000ms
2days 15hrs 30mins => 228600000ms
2 Hours 15 Minutes 10 Seconds => 8110000ms

在线演示

正则表达式演示

了解有关现代日期时间 API^{*< /sup> 来自跟踪：日期时间。}

---

^{* 如果您正在处理 Android 项目，并且您的 Android API 级别仍然不符合 Java-8，请检查 通过脱糖提供的 Java 8+ API。请注意，Android 8.0 Oreo 已提供 对 java.time 的支持。}

Answer 6

不，Joda 默认只获取持续时间、即时间隔和对象。对于后者，它接受日期或 SOAP ISO 格式等内容。您可以在此处为 Duration 类添加您自己的转换器，诚然，这会隐藏所有丑陋的代码。

Answer 7

不完全是 Java - 而是 Kotlin，并且不使用 Joda，而是使用 JDK 的 java.time：

val RELAXED_FORMATTER = DateTimeFormatter.ofPattern("yyyy[-MM[-dd[' 'HH:mm[:ss[.SSS]]]]]")

fun parseTemporalInput(input: String): LocalDateTime? {
    var result = LocalDateTime.MAX.withNano(0)

    if (input.lowercase() == "now")
        return LocalDateTime.now()

    try {
        val parsed = RELAXED_FORMATTER.parse(input)
        for (field in listOf(YEAR, MONTH_OF_YEAR, DAY_OF_MONTH, HOUR_OF_DAY, MINUTE_OF_HOUR, SECOND_OF_MINUTE)) {
            try {
                result = result.with(field, parsed.getLong(field))
            } catch (ex: UnsupportedTemporalTypeException) {
                result = result.with(field, if (field.isDateBased) 1 else 0)
            }
        }
        return result
    } 
    catch (parseEx: DateTimeParseException) {
        try {
            val inputToIso8601 = "P" + input.uppercase().replace("-","").replace(" ", "").replace("D", "DT").removeSuffix("T")
            // Expected format:  "PnDTnHnMn.nS"
            val duration = Duration.parse(inputToIso8601)

            val base = LocalDateTime.now().let {
                if (!inputToIso8601.contains("D")) it
                else it.truncatedTo(ChronoUnit.DAYS)
            }

            return base.minus(duration)
        }
        catch (ex: DateTimeParseException) {
            return null
        }
    }
    return null
}

• 仅支持天（因为底层 ISO 8601 没有标准化周、月等）。
• 不处理未来的相对值，虽然很容易添加。
• 并不意味着持续时间解析的全面实现，所以就这样吧。

摘自这个要点：
https://gist.github.com/OndraZizka/5fd56479ed2f6175703eb8a2e1bb1088

Answer 8

我意识到这个帖子已经有几年了，但它不断出现在谷歌搜索的顶部，所以我想我们应该分享这个。

这是用 Kotlin 编写的完整示例

import java.time.Duration
import java.util.regex.Pattern


fun Duration.toHumanReadableString(): String {
    val duration = this.truncatedTo(ChronoUnit.MILLIS)

    if (duration == Duration.ZERO) {
        return "0ms"
    }

    val elements = listOf(
        "${duration.toDaysPart()}d",
        "${duration.toHoursPart()}h",
        "${duration.toMinutesPart()}m",
        "${duration.toSecondsPart()}s",
        "${duration.toMillisPart()}ms"
    )
    val start = elements.indexOfFirst { it[0] != '0' }
    val end = elements.indexOfLast { it[0] != '0' }
    return elements.subList(start, end + 1).joinToString(" ")
}


internal val REGEX_DURATION = Pattern.compile("""
    ^(
       (
         ((?<days>\d+)d)?(\s*)
         ((?<hours>(0*(2[0-3]|[0-1]?[0-9])))h)?(\s*)
         ((?<minutes>(0*([0-5]?[0-9])))m)?(\s*)
         ((?<seconds>(0*([0-5]?[0-9])))s)?(\s*)
         ((?<milliseconds>(0*([0-9]|[1-9][0-9]|[1-9][0-9][0-9])))ms)?
      )
    | (
         ((?<days2>\d+)d)
        |((?<hours2>\d+)h)
        |((?<minutes2>\d+)m)
        |((?<seconds2>\d+)s)
        |((?<milliseconds2>\d+)ms)
      )
    )$
""".replace("\\s+".toRegex(), "")
        .trim())

internal const val MS = 1L
internal const val SEC = 1000 * MS
internal const val MIN = 60 * SEC
internal const val HOUR = 60 * MIN
internal const val DAY = 24 * HOUR

internal val GROUP_UNIT_CONVERTERS = mapOf(
        "days" to DAY,
        "hours" to HOUR,
        "minutes" to MIN,
        "seconds" to SEC,
        "milliseconds" to MS,
        "days2" to DAY,
        "hours2" to HOUR,
        "minutes2" to MIN,
        "seconds2" to SEC,
        "milliseconds2" to MS
)

fun String.toDuration(): Duration? {
    val matcher = REGEX_DURATION.matcher(this.trim())
    return if (matcher.matches()) {

        var durationNs = 0L

        GROUP_UNIT_CONVERTERS.forEach { (groupName, multiplier) ->
            val amount = matcher.group(groupName)?.toLong()
            if (amount != null)
                durationNs += amount * multiplier
        }
        Duration.ofMillis(durationNs)
    } else {
        null
    }
}