如何格式化java中的持续时间？（例如格式H：MM：SS）

https://stackoverflow.com/questions/266825

06-07-2019
|

题

我想使用像H：MM：SS这样的模式来格式化持续时间（以秒为单位）。 java中的当前实用程序旨在格式化时间而不是持续时间。

解决方案

如果您使用的是8之前的Java版本......您可以使用 Joda Time 和 PeriodFormatter 。如果你真的有一个持续时间（即没有参考日历系统的时间），那么你应该大部分时间使用 Duration - 然后你可以调用 toPeriod （指定 PeriodType ，你要反映25小时是否为1天1小时等），以获得可以格式化的 Period 。

如果您使用的是Java 8或更高版本：我通常建议使用 java.time.Duration 来表示持续时间。然后，您可以调用 getSeconds（）等来获取标准字符串格式的整数，如果需要，可以根据bobince的答案获取 - 尽管您应该注意持续时间为负的情况，因为可能需要输出字符串中的单负号。如下所示：

public static String formatDuration(Duration duration) {
    long seconds = duration.getSeconds();
    long absSeconds = Math.abs(seconds);
    String positive = String.format(
        "%d:%02d:%02d",
        absSeconds / 3600,
        (absSeconds % 3600) / 60,
        absSeconds % 60);
    return seconds < 0 ? "-" + positive : positive;
}

格式化这种方式合理简单，如果烦人的手动。对于解析一般来说它变得更难：如果你愿意的话，你仍然可以使用Joda Time，即使你也可以使用它。

其他提示

如果您不想在库中拖动，那么使用Formatter或相关的快捷方式就足够了。给定整数秒数：

  String.format("%d:%02d:%02d", s / 3600, (s % 3600) / 60, (s % 60));

我使用Apache common's DurationFormatUtils 如下：

DurationFormatUtils.formatDuration(millis, "**H:mm:ss**", true);

long duration = 4 * 60 * 60 * 1000;
SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss.SSS", Locale.getDefault());
log.info("Duration: " + sdf.format(new Date(duration - TimeZone.getDefault().getRawOffset())));

使用Java 9会更容易。 Duration 仍然不是可格式化的（我所知道的），但是添加了获取小时，分钟和秒的方法，这使得任务有点更直接：

        Duration diff = // ...;
        String hms = String.format("%d:%02d:%02d", 
                                   diff.toHoursPart(),
                                   diff.toMinutesPart(), 
                                   diff.toSecondsPart());

这可能是一种hacky，但如果一个人倾向于使用Java 8的 java.time 来实现这一点，这是一个很好的解决方案：

import java.time.Duration;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeFormatterBuilder;
import java.time.temporal.ChronoField;
import java.time.temporal.Temporal;
import java.time.temporal.TemporalAccessor;
import java.time.temporal.TemporalField;
import java.time.temporal.UnsupportedTemporalTypeException;

public class TemporalDuration implements TemporalAccessor {
    private static final Temporal BASE_TEMPORAL = LocalDateTime.of(0, 1, 1, 0, 0);

    private final Duration duration;
    private final Temporal temporal;

    public TemporalDuration(Duration duration) {
        this.duration = duration;
        this.temporal = duration.addTo(BASE_TEMPORAL);
    }

    @Override
    public boolean isSupported(TemporalField field) {
        if(!temporal.isSupported(field)) return false;
        long value = temporal.getLong(field)-BASE_TEMPORAL.getLong(field);
        return value!=0L;
    }

    @Override
    public long getLong(TemporalField field) {
        if(!isSupported(field)) throw new UnsupportedTemporalTypeException(new StringBuilder().append(field.toString()).toString());
        return temporal.getLong(field)-BASE_TEMPORAL.getLong(field);
    }

    public Duration getDuration() {
        return duration;
    }

    @Override
    public String toString() {
        return dtf.format(this);
    }

    private static final DateTimeFormatter dtf = new DateTimeFormatterBuilder()
            .optionalStart()//second
            .optionalStart()//minute
            .optionalStart()//hour
            .optionalStart()//day
            .optionalStart()//month
            .optionalStart()//year
            .appendValue(ChronoField.YEAR).appendLiteral(" Years ").optionalEnd()
            .appendValue(ChronoField.MONTH_OF_YEAR).appendLiteral(" Months ").optionalEnd()
            .appendValue(ChronoField.DAY_OF_MONTH).appendLiteral(" Days ").optionalEnd()
            .appendValue(ChronoField.HOUR_OF_DAY).appendLiteral(" Hours ").optionalEnd()
            .appendValue(ChronoField.MINUTE_OF_HOUR).appendLiteral(" Minutes ").optionalEnd()
            .appendValue(ChronoField.SECOND_OF_MINUTE).appendLiteral(" Seconds").optionalEnd()
            .toFormatter();

}

这将成为java 7中的新功能之一

JSR-310

以下是另一个如何格式化持续时间的示例。请注意，此示例将正和负持续时间显示为正持续时间。

import static java.time.temporal.ChronoUnit.DAYS;
import static java.time.temporal.ChronoUnit.HOURS;
import static java.time.temporal.ChronoUnit.MINUTES;
import static java.time.temporal.ChronoUnit.SECONDS;

import java.time.Duration;

public class DurationSample {
    public static void main(String[] args) {
        //Let's say duration of 2days 3hours 12minutes and 46seconds
        Duration d = Duration.ZERO.plus(2, DAYS).plus(3, HOURS).plus(12, MINUTES).plus(46, SECONDS);

        //in case of negative duration
        if(d.isNegative()) d = d.negated();

        //format DAYS HOURS MINUTES SECONDS 
        System.out.printf("Total duration is %sdays %shrs %smin %ssec.\n", d.toDays(), d.toHours() % 24, d.toMinutes() % 60, d.getSeconds() % 60);

        //or format HOURS MINUTES SECONDS 
        System.out.printf("Or total duration is %shrs %smin %sec.\n", d.toHours(), d.toMinutes() % 60, d.getSeconds() % 60);

        //or format MINUTES SECONDS 
        System.out.printf("Or total duration is %smin %ssec.\n", d.toMinutes(), d.getSeconds() % 60);

        //or format SECONDS only 
        System.out.printf("Or total duration is %ssec.\n", d.getSeconds());
    }
}

这是一个可行的选择。

public static String showDuration(LocalTime otherTime){          
    DateTimeFormatter df = DateTimeFormatter.ISO_LOCAL_TIME;
    LocalTime now = LocalTime.now();
    System.out.println("now: " + now);
    System.out.println("otherTime: " + otherTime);
    System.out.println("otherTime: " + otherTime.format(df));

    Duration span = Duration.between(otherTime, now);
    LocalTime fTime = LocalTime.ofNanoOfDay(span.toNanos());
    String output = fTime.format(df);

    System.out.println(output);
    return output;
}

使用

调用方法

System.out.println(showDuration(LocalTime.of(9, 30, 0, 0)));

产生类似的东西：

otherTime: 09:30
otherTime: 09:30:00
11:31:27.463
11:31:27.463

以下函数如何返回 + H：MM：SS 要么 + H：MM：SS.SSS

public static String formatInterval(final long interval, boolean millisecs )
{
    final long hr = TimeUnit.MILLISECONDS.toHours(interval);
    final long min = TimeUnit.MILLISECONDS.toMinutes(interval) %60;
    final long sec = TimeUnit.MILLISECONDS.toSeconds(interval) %60;
    final long ms = TimeUnit.MILLISECONDS.toMillis(interval) %1000;
    if( millisecs ) {
        return String.format("%02d:%02d:%02d.%03d", hr, min, sec, ms);
    } else {
        return String.format("%02d:%02d:%02d", hr, min, sec );
    }
}

String duration(Temporal from, Temporal to) {
    final StringBuilder builder = new StringBuilder();
    for (ChronoUnit unit : new ChronoUnit[]{YEARS, MONTHS, WEEKS, DAYS, HOURS, MINUTES, SECONDS}) {
        long amount = unit.between(from, to);
        if (amount == 0) {
            continue;
        }
        builder.append(' ')
                .append(amount)
                .append(' ')
                .append(unit.name().toLowerCase());
        from = from.plus(amount, unit);
    }
    return builder.toString().trim();
}

此答案仅使用 Duration 方法，并适用于Java 8：

public static String format(Duration d) {
    long days = d.toDays();
    d = d.minusDays(days);
    long hours = d.toHours();
    d = d.minusHours(hours);
    long minutes = d.toMinutes();
    d = d.minusMinutes(minutes);
    long seconds = d.getSeconds() ;
    return 
            (days ==  0?"":days+" jours,")+ 
            (hours == 0?"":hours+" heures,")+ 
            (minutes ==  0?"":minutes+" minutes,")+ 
            (seconds == 0?"":seconds+" secondes,");
}

有一种相当简单且（IMO）优雅的方法，至少持续时间不到24小时：

DateTimeFormatter.ISO_LOCAL_TIME.format（value.addTo（LocalTime.of（0,0）））

格式化程序需要一个时态对象进行格式化，因此您可以通过将持续时间添加到00:00（即午夜）的LocalTime来创建一个。这将为您提供一个LocalTime，表示从午夜到该时间的持续时间，然后可以使用标准HH：mm：ss表示法进行格式化。这样做的好处是不需要外部库，并使用java.time库进行计算，而不是手动计算小时，分钟和秒。

我的图书馆 Time4J 提供基于模式的解决方案（类似于 Apache DurationFormatUtils ，但更灵活）：



Duration<ClockUnit> duration =
    Duration.of(-573421, ClockUnit.SECONDS) // input in seconds only
    .with(Duration.STD_CLOCK_PERIOD); // performs normalization to h:mm:ss-structure
String fs = Duration.formatter(ClockUnit.class, "+##h:mm:ss").format(duration);
System.out.println(fs); // output => -159:17:01


此代码演示了处理小时溢出和符号处理的功能，另请参阅duration-formatter的API 基于模式。



	
		
	
	
			在Scala中，构建了YourBestBet的解决方案，但简化了：

def prettyDuration(seconds: Long): List[String] = seconds match {
  case t if t < 60      => List(s"${t} seconds")
  case t if t < 3600    => s"${t / 60} minutes" :: prettyDuration(t % 60)
  case t if t < 3600*24 => s"${t / 3600} hours" :: prettyDuration(t % 3600)
  case t                => s"${t / (3600*24)} days" :: prettyDuration(t % (3600*24))
}

val dur = prettyDuration(12345).mkString(", ") // => 3 hours, 25 minutes, 45 seconds
	


	
		
	
	
			在scala中，不需要库：

def prettyDuration(str:List[String],seconds:Long):List[String]={
  seconds match {
    case t if t < 60 => str:::List(s"${t} seconds")
    case t if (t >= 60 && t< 3600 ) => List(s"${t / 60} minutes"):::prettyDuration(str, t%60)
    case t if (t >= 3600 && t< 3600*24 ) => List(s"${t / 3600} hours"):::prettyDuration(str, t%3600)
    case t if (t>= 3600*24 ) => List(s"${t / (3600*24)} days"):::prettyDuration(str, t%(3600*24))
  }
}
val dur = prettyDuration(List.empty[String], 12345).mkString("")
	


	
		
	
	
			我没有看到这个，所以我想我会添加它：

Date started=new Date();
SimpleDateFormat format = new SimpleDateFormat("HH:mm:ss");
task
long duration=new Date().getTime()-started.getTime();
System.out.println(format.format(new Date(duration));


它只能工作24小时，但这是我通常想要的持续时间。



	
		
			许可以下： CC-BY-SA 和 归因
			不隶属于 StackOverflow

如何格式化java中的持续时间？ （例如格式H：MM：SS）

如何格式化java中的持续时间？（例如格式H：MM：SS）