如何在Java中解析基于时间的令牌？（1m 1M 1d 1Y 1W 1S）

时间：2019-02-25 12:06:32

标签： java datetime duration localdate

我从FE中得到以下字符串：

1m
5M
3D
30m
2h
1Y
3W

对应于1分钟，5个月，3天，30分钟，2小时，1年，3周。

在Java中解析它意味着什么？

我想用Instant（或LocalDatetTime）进行操作（加/减）。有没有办法在Java中做到这一点？

7 个答案:

答案 0 :(得分：3)

Period和Duration

我认为以下解决方案简单而通用（不是完全通用）。

public static TemporalAmount parse(String feString) {
    if (Character.isUpperCase(feString.charAt(feString.length() - 1))) {
        return Period.parse("P" + feString);
    } else {
        return Duration.parse("PT" + feString);
    }
}

似乎您基于日期的单位（年，月，周，日）用大写缩写表示（Y，M，W和D）而基于时间的小时和小时则为小写（h和m）。因此，我测试了字符串的最后一个字符的大小写，以确定是解析为Period还是Duration。我利用Period.parse和Duration.parse都接受字母的事实。

您想在Instant或LocalDateTime之间添加或减去持续时间。这在大多数情况下有效。让我们看看：

    String[] timeAmountStrings = { "1m", "5M", "3D", "30m", "2h", "1Y", "3W" };
    LocalDateTime base = LocalDateTime.of(2019, Month.MARCH, 1, 0, 0);
    for (String tas : timeAmountStrings) {
        TemporalAmount amount = parse(tas);
        System.out.println("String: " + tas + " parsed: " + amount + " added: " + base.plus(amount));

        try {
            System.out.println("Added to Instant: " + Instant.EPOCH.plus(amount));
        } catch (DateTimeException dte) {
            System.out.println("Adding to Instant didn’t work: " + tas + ' ' + dte);
        }

        System.out.println();
    }

输出：

String: 1m parsed: PT1M added: 2019-03-01T00:01
Added to Instant: 1970-01-01T00:01:00Z

String: 5M parsed: P5M added: 2019-08-01T00:00
Adding to Instant didn’t work: 5M java.time.temporal.UnsupportedTemporalTypeException: Unsupported unit: Months

String: 3D parsed: P3D added: 2019-03-04T00:00
Added to Instant: 1970-01-04T00:00:00Z

String: 30m parsed: PT30M added: 2019-03-01T00:30
Added to Instant: 1970-01-01T00:30:00Z

String: 2h parsed: PT2H added: 2019-03-01T02:00
Added to Instant: 1970-01-01T02:00:00Z

String: 1Y parsed: P1Y added: 2020-03-01T00:00
Adding to Instant didn’t work: 1Y java.time.temporal.UnsupportedTemporalTypeException: Unsupported unit: Years

String: 3W parsed: P21D added: 2019-03-22T00:00
Added to Instant: 1970-01-22T00:00:00Z

我们看到在所有情况下都可以添加到LocalDateTime中。在大多数情况下，添加到Instant都是可行的，只有我们不能在其中添加几个月或几年的时间。

答案 1 :(得分：2)

Answer by Ole V.V.是正确，聪明并且做得很好的。我将更进一步。

PeriodDuration

ThreeTen-Extra项目为Java 8及更高版本中内置的 java.time 类添加了功能。它提供了PeriodDuration类，将Period（年-月-日）与Duration（小时-分钟-秒-nanos）结合在一起。

顺便说一句，让我告诫您有关结合这两个概念的问题。尽管从直觉上看似乎不错，但是如果您仔细考虑一下，可能会发现它有问题，具体取决于您的业务逻辑。

无论如何，让我们修改在其他答案中看到的代码。

  • 如果输入为大写，我们将以标准ISO 8601 duration格式创建一个字符串，并将其解析为Period，然后将该结果添加到我们的PeriodDuration对象中。
  • 如果输入是小写字母，我们将以标准ISO 8601持续时间格式创建一个字符串，将其解析为Duration，然后将结果添加到我们的PeriodDuration对象中。

代码：

List < String > inputs = List.of( "1m" , "5M" , "3D" , "30m" , "2h" , "1Y" , "3W" );
PeriodDuration pd = PeriodDuration.ZERO;
for ( String input : inputs )
{
    String s = input.trim();
    String lastLetter = s.substring( s.length() - 1 );
    int codepoint = Character.codePointAt( lastLetter , 0 );
    if ( Character.isUpperCase( codepoint ) )
    {
        String x = "P" + s;
        Period p = Period.parse( x );
        pd = pd.plus( p );
    } else
    { // Else, lowercase.
        String x = "PT".concat( s ).toUpperCase();
        Duration d = Duration.parse(x );
        pd = pd.plus( d );
    }
}
System.out.println( "pd.toString(): " + pd );
  

P1Y5M24DT2H31M

答案 2 :(得分：1)

由于包含了年份和分钟，因此建议您使用注释中提到的一对Duration和Period解析。使用静态方法Period::parse(CharSequence text)和Duration.parse(CharSequence text)为其默认格式（PnDTnHnMn.nS使用Duration，PnYnMnD使用Period），因为它们不提供一种翻译自定义表达式的方式。

对于此用例，您必须在表达式和给定格式之间创建自己的映射。

答案 3 :(得分：0)

我的猜测是，您应该使用java.util.concurrent.TimeUnit创建自己的解析器方法，然后可以使用任何框架添加秒数

private static long convertToSeconds(int value, char unit)
{
    long ret = value;
    switch (unit)
    {
    case 'd':
        ret = TimeUnit.DAYS.toSeconds(value);
        break;
    case 'h':
        ret = TimeUnit.HOURS.toSeconds(value);
        break;
    case 'm':
        ret = TimeUnit.MINUTES.toSeconds(value);
        break;
    case 's':
        break;
    default:
        // fail
        break;
    }
    return ret;
}

答案 4 :(得分：0)

正如@Achinta Jha所建议的那样，您可以使用类似的东西来实现简单的解析逻辑

public static void main(String[] args) {
        final String[] inputs = {"1m", "5M", "3D"/*, "30m", "2h", "1Y", "3W"*/};

        Arrays.stream(inputs)
                .map(x -> Parse(x))
                .forEach(System.out::println);

    }

    private static final Map<Character, Function<String, Duration>> parsers = new HashMap<>();
    static {
        parsers.put('m', txt -> Duration.ofMinutes(Integer.parseInt(txt)));
        parsers.put('M', txt -> Duration.ofDays(30 * Integer.parseInt(txt)));
        parsers.put('D', txt -> Duration.ofDays(Integer.parseInt(txt)));
    }

    private static Duration Parse(String txt) {
        Character last = txt.charAt(txt.length() - 1);
        Function<String, Duration> parser = parsers.get(last);
        return parser.apply(txt.substring(0, txt.length() - 1));
    }

这是一个简单的说明性实现，既没有错误/ null的处理，也没有对建议的输入的完全支持。 请注意，Duration不支持静态的ofMonths方法：我以为您打算使用30 days，但是由您自己决定将代码调整为所需的语义。

要添加/减去Duration，可以使用Duration class的非静态方法。

答案 5 :(得分：0)

Spring已经做到了这一点，但没有与您相同的选项。 Their implementation is 

private static Duration simpleParse(String rawTime) {
    if (rawTime == null || rawTime.isEmpty())
        return null;
    if (!Character.isDigit(rawTime.charAt(0)))
        return null;

    String time = rawTime.toLowerCase();
    return tryParse(time, "ns", Duration::ofNanos)
            .orElseGet(() -> tryParse(time, "ms", Duration::ofMillis).orElseGet(
                    () -> tryParse(time, "s", Duration::ofSeconds).orElseGet(
                            () -> tryParse(time, "m", Duration::ofMinutes).orElseGet(
                                    () -> tryParse(time, "h", Duration::ofHours)
                                            .orElseGet(() -> tryParse(time, "d",
                                                    Duration::ofDays)
                                                            .orElse(null))))));
}

private static Optional<Duration> tryParse(String time, String unit,
        Function<Long, Duration> toDuration) {
    if (time.endsWith(unit)) {
        String trim = time.substring(0, time.lastIndexOf(unit)).trim();
        try {
            return Optional.of(toDuration.apply(Long.parseLong(trim)));
        }
        catch (NumberFormatException ignore) {
            return Optional.empty();
        }
    }
    return Optional.empty();
}

答案 6 :(得分：0)

没有直接解析，但是您可以自己进行解析：

// TODO: Proper variable/method names, comments, logging, code format, etc.
java.time.LocalDateTime changeDateTimeByString(java.time.LocalDateTime current, String part,
                                               boolean increaseOrDecrease){
  java.time.LocalDateTime newDateTime = null;

  Integer amount = Integer.parseInt(part.replaceAll("\\D",""));
  if(part.contains("S"))
    newDateTime = increaseOrDecrease ? current.plusSeconds(amount) : current.minusSeconds(amount);
  else if(part.contains("m"))
    newDateTime = increaseOrDecrease ? current.plusMinutes(amount) : current.minusMinutes(amount);
  else if(part.contains("h"))
    newDateTime = increaseOrDecrease ? current.plusHours(amount) : current.minusHours(amount);
  else if(part.contains("D"))
    newDateTime = increaseOrDecrease ? current.plusDays(amount) : current.minusDays(amount);
  else if(part.contains("W"))
    newDateTime = increaseOrDecrease ? current.plusDays(amount * 7) : current.minusDays(amount * 7);
  else if(part.contains("M"))
    newDateTime = increaseOrDecrease ? current.plusMonths(amount) : current.minusMonths(amount);
  else if(part.contains("Y"))
    newDateTime = increaseOrDecrease ? current.plusYears(amount) : current.minusYears(amount);
  else
    System.err.println("Unknown format: " + part);

  System.out.println("New dateTime after "+(increaseOrDecrease?"adding":"removing")+" "+part+": "+newDateTime);
  return newDateTime;
}

方法的参数是您在问题中指定的字符串；一个布尔值，是否要添加或移动它；以及您要修改的输入日期。然后它将返回修改的日期（在这种情况下使用Java 8+ java.time.LocalDateTime）。即：changeDateTimeByString(dateTime, "1m", true);将增加1分钟； changeDateTimeByString(dateTime, "2Y", false);将删除2年。

Try it online.

相关问题
最新问题