如何在java中解析基于时间的标记？（1m 1M 1d 1Y 1W 1S）

问题描述 投票：2回答：7

我从FE获取以下字符串：

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

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

在java中有解析它的意思吗？

我想用Instant（或LocalDatetime）操纵（加/减）。有没有办法在java中做到这一点？

java datetime duration localdate
7个回答
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工作，只有我们不能添加几个月或几年的时间。

2
投票

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

PeriodDuration

ThreeTen-Extra项目为Java 8及更高版本中内置的java.time类添加了功能。它的产品之一是PeriodDuration类，结合了Period（年 - 月 - 天）和Duration（小时 - 分 - 秒 - 纳米）。

顺便说一句，让我告诫你们将这两个概念结合起来。虽然这看起来很直观，但如果你仔细思考一下，根据你的业务逻辑，你可能会发现它有问题。

无论如何，让我们调整另一个答案中看到的代码。

  • 如果输入是大写的，我们用标准的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

1
投票

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

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

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;
}
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));
    }

这是一个简单的解释性实现，既没有错误/ nulls处理也没有完全支持建议的输入。请注意，Duration不支持静态ofMonths方法：我认为你打算使用30 days，但是由你决定将代码调整到你想要的语义。

为了添加/减去Durations，你可以使用Duration class的非静态方法。

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();
}
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;
}

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

Try it online.

最新问题
© www.soinside.com 2019 - 2024. All rights reserved.