Kennt jemand eine Java-Bibliothek, die eine Zahl in Millisekunden genauso drucken kann wie C #?

Beispielsweise würden 123456 ms als 4d1h3m5s gedruckt.

Joda Time hat eine ziemlich gute Möglichkeit, dies mit einem PeriodFormatterBuilder zu tun .

Schneller Gewinn: PeriodFormat.getDefault().print(duration.toPeriod());

z.B

//import org.joda.time.format.PeriodFormatter;
//import org.joda.time.format.PeriodFormatterBuilder;
//import org.joda.time.Duration;

Duration duration = new Duration(123456); // in milliseconds
PeriodFormatter formatter = new PeriodFormatterBuilder()
     .appendDays()
     .appendSuffix("d")
     .appendHours()
     .appendSuffix("h")
     .appendMinutes()
     .appendSuffix("m")
     .appendSeconds()
     .appendSuffix("s")
     .toFormatter();
String formatted = formatter.print(duration.toPeriod());
System.out.println(formatted);

Ich habe eine einfache Lösung mit Java 8 Duration.toString()und ein bisschen Regex erstellt:

public static String humanReadableFormat(Duration duration) {
    return duration.toString()
            .substring(2)
            .replaceAll("(\\d[HMS])(?!$)", "$1 ")
            .toLowerCase();
}

Das Ergebnis sieht folgendermaßen aus:

- 5h
- 7h 15m
- 6h 50m 15s
- 2h 5s
- 0.1s

Wenn Sie keine Leerzeichen dazwischen möchten, entfernen Sie einfach replaceAll.

Apache commons-lang bietet eine nützliche Klasse, um dies ebenfalls zu erledigen. DurationFormatUtils

zB DurationFormatUtils.formatDurationHMS( 15362 * 1000 ) )=> 4: 16: 02.000 (H: m: s.millis) DurationFormatUtils.formatDurationISO( 15362 * 1000 ) )=> P0Y0M0DT4H16M2.000S, vgl. ISO8601

JodaTime hat eine PeriodKlasse, die solche Größen darstellen kann und (via IsoPeriodFormat) im ISO8601- Format gerendert werden kann PT4D1H3M5S, z

Period period = new Period(millis);
String formatted = ISOPeriodFormat.standard().print(period);

Wenn dieses Format nicht das gewünschte ist, PeriodFormatterBuilderkönnen Sie beliebige Layouts zusammenstellen, einschließlich Ihres C # -Stils 4d1h3m5s.

Mit Java 8 können Sie auch die toString()Methode verwenden, java.time.Durationum es ohne externe Bibliotheken mit einer auf ISO 8601 Sekunden basierenden Darstellung wie PT8H6M12.345S zu formatieren.

So können Sie dies mit reinem JDK-Code tun:

import javax.xml.datatype.DatatypeFactory;
import javax.xml.datatype.Duration;

long diffTime = 215081000L;
Duration duration = DatatypeFactory.newInstance().newDuration(diffTime);

System.out.printf("%02d:%02d:%02d", duration.getDays() * 24 + duration.getHours(), duration.getMinutes(), duration.getSeconds()); 

org.threeten.extra.AmountFormats.wordBased

Das ThreeTen-Extra- Projekt, das von Stephen Colebourne, dem Autor von JSR 310, java.time und Joda-Time , verwaltet wird, verfügt über eine AmountFormatsKlasse, die mit den Standard-Java 8-Datumszeitklassen funktioniert. Es ist jedoch ziemlich ausführlich und bietet keine Option für eine kompaktere Ausgabe.

Duration d = Duration.ofMinutes(1).plusSeconds(9).plusMillis(86);
System.out.println(AmountFormats.wordBased(d, Locale.getDefault()));

1 minute, 9 seconds and 86 milliseconds

Java 9+

Duration d1 = Duration.ofDays(0);
        d1 = d1.plusHours(47);
        d1 = d1.plusMinutes(124);
        d1 = d1.plusSeconds(124);
System.out.println(String.format("%s d %sh %sm %ss", 
                d1.toDaysPart(), 
                d1.toHoursPart(), 
                d1.toMinutesPart(), 
                d1.toSecondsPart()));

2 d 1h 6m 4s

Eine Alternative zum Builder-Ansatz von Joda-Time wäre eine musterbasierte Lösung . Dies wird von meiner Bibliothek Time4J angeboten . Beispiel mit der Klasse Duration.Formatter (einige Leerzeichen zur besseren Lesbarkeit hinzugefügt - das Entfernen der Leerzeichen ergibt den gewünschten C # -Stil):

IsoUnit unit = ClockUnit.MILLIS;
Duration<IsoUnit> dur = // normalized duration with multiple components
  Duration.of(123456, unit).with(Duration.STD_PERIOD);
Duration.Formatter<IsoUnit> f = // create formatter/parser with optional millis
  Duration.Formatter.ofPattern("D'd' h'h' m'm' s[.fff]'s'");

System.out.println(f.format(dur)); // output: 0d 0h 2m 3.456s

Dieser Formatierer kann auch die Dauer von java.time-API drucken (die Normalisierungsfunktionen dieses Typs sind jedoch weniger leistungsfähig):

System.out.println(f.format(java.time.Duration.ofMillis(123456))); // output: 0d 0h 2m 3.456s

Die Erwartung des OP, dass "123456 ms so lang wie 4d1h3m5s gedruckt werden", wird offensichtlich falsch berechnet. Ich nehme Schlamperei als Grund an. Der oben definierte Dauerformatierer kann auch als Parser verwendet werden. Der folgende Code zeigt, dass "4d1h3m5s" eher entspricht 349385000 = 1000 * (4 * 86400 + 1 * 3600 + 3 * 60 + 5):

System.out.println(
  f.parse("4d 1h 3m 5s")
   .toClockPeriodWithDaysAs24Hours()
   .with(unit.only())
   .getPartialAmount(unit)); // 349385000

Eine andere Möglichkeit ist die Verwendung der Klasse net.time4j.PrettyTime(die auch für die lokalisierte Ausgabe und das Drucken relativer Zeiten wie "gestern", "nächsten Sonntag", "vor 4 Tagen" usw. geeignet ist):

String s = PrettyTime.of(Locale.ENGLISH).print(dur, TextWidth.NARROW);
System.out.println(s); // output: 2m 3s 456ms

s = PrettyTime.of(Locale.ENGLISH).print(dur, TextWidth.WIDE);
System.out.println(s); // output: 2 minutes, 3 seconds, and 456 milliseconds

s = PrettyTime.of(Locale.UK).print(dur, TextWidth.WIDE);
System.out.println(s); // output: 2 minutes, 3 seconds and 456 milliseconds

Die Textbreite steuert, ob Abkürzungen verwendet werden oder nicht. Das Listenformat kann auch durch Auswahl des entsprechenden Gebietsschemas gesteuert werden. In Standard-Englisch wird beispielsweise das Oxform-Komma verwendet, in Großbritannien jedoch nicht. Die neueste Version 5.5 von Time4J unterstützt mehr als 90 Sprachen und verwendet Übersetzungen, die auf dem CLDR-Repository (einem Industriestandard) basieren.

Eine Java 8- Version basierend auf der Antwort von user678573 :

private static String humanReadableFormat(Duration duration) {
    return String.format("%s days and %sh %sm %ss", duration.toDays(),
            duration.toHours() - TimeUnit.DAYS.toHours(duration.toDays()),
            duration.toMinutes() - TimeUnit.HOURS.toMinutes(duration.toHours()),
            duration.getSeconds() - TimeUnit.MINUTES.toSeconds(duration.toMinutes()));
}

... da es in Java 8 keinen PeriodFormatter gibt und keine Methoden wie getHours, getMinutes, ...

Ich würde mich freuen, eine bessere Version für Java 8 zu sehen.

Mir ist klar, dass dies möglicherweise nicht genau zu Ihrem Anwendungsfall passt, aber PrettyTime kann hier hilfreich sein.

PrettyTime p = new PrettyTime();
System.out.println(p.format(new Date()));
//prints: “right now”

System.out.println(p.format(new Date(1000*60*10)));
//prints: “10 minutes from now”