Comment convertir des millisecondes au format "hh: mm: ss"?
Je suis confus. Après être tombé par hasard sur le fil this , j'ai essayé de comprendre comment formater un compte à rebours au format hh:mm:ss.
Voici ma tentative -
//hh:mm:ss
String.format("%02d:%02d:%02d",
TimeUnit.MILLISECONDS.toHours(millis),
TimeUnit.MILLISECONDS.toMinutes(millis) -
TimeUnit.MINUTES.toMinutes(TimeUnit.MILLISECONDS.toHours(millis)),
TimeUnit.MILLISECONDS.toSeconds(millis) -
TimeUnit.MINUTES.toSeconds(TimeUnit.MILLISECONDS.toMinutes(millis)));
Ainsi, lorsque j'essaie une valeur comme 3600000ms, j'obtiens 01:59:00, ce qui est faux car il devrait s'agir de 01:00:00. De toute évidence, il y a quelque chose qui cloche dans ma logique, mais pour le moment, je ne vois pas ce que c'est!
Quelqu'un peut-il aider?
Modifier -
Fixe le. Voici le bon moyen de formater des millisecondes au format hh:mm:ss -
//hh:mm:ss
String.format("%02d:%02d:%02d",
TimeUnit.MILLISECONDS.toHours(millis),
TimeUnit.MILLISECONDS.toMinutes(millis) -
TimeUnit.HOURS.toMinutes(TimeUnit.MILLISECONDS.toHours(millis)),
TimeUnit.MILLISECONDS.toSeconds(millis) -
TimeUnit.MINUTES.toSeconds(TimeUnit.MILLISECONDS.toMinutes(millis))));
Le problème était ceci TimeUnit.MINUTES.toMinutes(TimeUnit.MILLISECONDS.toHours(millis)). Cela aurait dû être cette TimeUnit.HOURS.toMinutes(TimeUnit.MILLISECONDS.toHours(millis)) à la place.
Vous étiez vraiment proche:
String.format("%02d:%02d:%02d",
TimeUnit.MILLISECONDS.toHours(millis),
TimeUnit.MILLISECONDS.toMinutes(millis) -
TimeUnit.HOURS.toMinutes(TimeUnit.MILLISECONDS.toHours(millis)), // The change is in this line
TimeUnit.MILLISECONDS.toSeconds(millis) -
TimeUnit.MINUTES.toSeconds(TimeUnit.MILLISECONDS.toMinutes(millis)));
Vous convertissiez des heures en millisecondes en utilisant minutes au lieu de heures.
Au fait, j'aime bien votre utilisation de l'API TimeUnit :)
Voici un code de test:
public static void main(String[] args) throws ParseException {
long millis = 3600000;
String hms = String.format("%02d:%02d:%02d", TimeUnit.MILLISECONDS.toHours(millis),
TimeUnit.MILLISECONDS.toMinutes(millis) - TimeUnit.HOURS.toMinutes(TimeUnit.MILLISECONDS.toHours(millis)),
TimeUnit.MILLISECONDS.toSeconds(millis) - TimeUnit.MINUTES.toSeconds(TimeUnit.MILLISECONDS.toMinutes(millis)));
System.out.println(hms);
}
Sortie:
01:00:00
J'ai réalisé que mon code ci-dessus peut être grandement simplifié en utilisant une division de module au lieu d'une soustraction:
String hms = String.format("%02d:%02d:%02d", TimeUnit.MILLISECONDS.toHours(millis),
TimeUnit.MILLISECONDS.toMinutes(millis) % TimeUnit.HOURS.toMinutes(1),
TimeUnit.MILLISECONDS.toSeconds(millis) % TimeUnit.MINUTES.toSeconds(1));
J'utilise toujours l'API TimeUnit pour toutes les valeurs magiques et donne exactement le même résultat.
La méthode générique pour cela est assez simple:
public static String convertSecondsToHMmSs(long seconds) {
long s = seconds % 60;
long m = (seconds / 60) % 60;
long h = (seconds / (60 * 60)) % 24;
return String.format("%d:%02d:%02d", h,m,s);
}
Si vous utilisez Apache commons:
DurationFormatUtils.formatDuration(timeInMS, "HH:mm:ss,SSS");
// New date object from millis
Date date = new Date(millis);
// formattter
SimpleDateFormat formatter= new SimpleDateFormat("HH:mm:ss.SSS");
formatter.setTimeZone(TimeZone.getTimeZone("UTC"));
// Pass date object
String formatted = formatter.format(date );
Voir exemple exécutable en utilisant une entrée de 1200 ms.
J'ai utilisé ceci:
String.format("%1$tH:%1$tM:%1$tS.%1$tL", millis);
Voir la description de la classe Formatter .
Voir exemple exécutable en utilisant une entrée de 2400 ms.
DateFormat df = new SimpleDateFormat("HH:mm:ss");
String formatted = df.format(aDateObject);
Résultats du test pour les 4 implémentations
Devoir faire beaucoup de formatage pour des données volumineuses, nécessitait la meilleure performance, voici donc les résultats (surprenants):
pour (int i = 0; i <1000000; i ++) {FUNCTION_CALL}
Durées:
- combinaisonFormatter: 196 millis
- formatDurée: 272 millis
- apacheFormat: 754 millis
formatTimeUnit: 2216 millis
public static String apacheFormat(long millis) throws ParseException { return DurationFormatUtils.formatDuration(millis, "HH:mm:ss"); } public static String formatTimeUnit(long millis) throws ParseException { String formatted = String.format( "%02d:%02d:%02d", TimeUnit.MILLISECONDS.toHours(millis), TimeUnit.MILLISECONDS.toMinutes(millis) - TimeUnit.HOURS.toMinutes(TimeUnit.MILLISECONDS.toHours(millis)), TimeUnit.MILLISECONDS.toSeconds(millis) - TimeUnit.MINUTES.toSeconds(TimeUnit.MILLISECONDS.toMinutes(millis))); return formatted; } public static String formatDuration(final long millis) { long seconds = (millis / 1000) % 60; long minutes = (millis / (1000 * 60)) % 60; long hours = millis / (1000 * 60 * 60); StringBuilder b = new StringBuilder(); b.append(hours == 0 ? "00" : hours < 10 ? String.valueOf("0" + hours) : String.valueOf(hours)); b.append(":"); b.append(minutes == 0 ? "00" : minutes < 10 ? String.valueOf("0" + minutes) : String.valueOf(minutes)); b.append(":"); b.append(seconds == 0 ? "00" : seconds < 10 ? String.valueOf("0" + seconds) : String.valueOf(seconds)); return b.toString(); } public static String combinationFormatter(final long millis) { long seconds = TimeUnit.MILLISECONDS.toSeconds(millis) - TimeUnit.MINUTES.toSeconds(TimeUnit.MILLISECONDS.toMinutes(millis)); long minutes = TimeUnit.MILLISECONDS.toMinutes(millis) - TimeUnit.HOURS.toMinutes(TimeUnit.MILLISECONDS.toHours(millis)); long hours = TimeUnit.MILLISECONDS.toHours(millis); StringBuilder b = new StringBuilder(); b.append(hours == 0 ? "00" : hours < 10 ? String.valueOf("0" + hours) : String.valueOf(hours)); b.append(":"); b.append(minutes == 0 ? "00" : minutes < 10 ? String.valueOf("0" + minutes) : String.valueOf(minutes)); b.append(":"); b.append(seconds == 0 ? "00" : seconds < 10 ? String.valueOf("0" + seconds) : String.valueOf(seconds)); return b.toString(); }
Le code ci-dessous fait la conversion dans les deux sens
23: 59: 58: 999 à 86398999
et que
86398999 à 23: 59: 58: 999
import Java.util.concurrent.TimeUnit;
public class TimeUtility {
public static void main(String[] args) {
long currentDateTime = System.currentTimeMillis();
String strTest = "23:59:58:999";
System.out.println(strTest);
long l = strToMilli(strTest);
System.out.println(l);
l += 1;
String str = milliToString(l);
System.out.println(str);
}
/**
* convert a time string into the equivalent long milliseconds
*
* @param strTime string fomratted as HH:MM:SS:MSMS i.e. "23:59:59:999"
* @return long integer like 86399999
*/
public static long strToMilli(String strTime) {
long retVal = 0;
String hour = strTime.substring(0, 2);
String min = strTime.substring(3, 5);
String sec = strTime.substring(6, 8);
String milli = strTime.substring(9, 12);
int h = Integer.parseInt(hour);
int m = Integer.parseInt(min);
int s = Integer.parseInt(sec);
int ms = Integer.parseInt(milli);
String strDebug = String.format("%02d:%02d:%02d:%03d", h, m, s, ms);
//System.out.println(strDebug);
long lH = h * 60 * 60 * 1000;
long lM = m * 60 * 1000;
long lS = s * 1000;
retVal = lH + lM + lS + ms;
return retVal;
}
/**
* convert time in milliseconds to the corresponding string, in case of day
* rollover start from scratch 23:59:59:999 + 1 = 00:00:00:000
*
* @param millis the number of milliseconds corresponding to tim i.e.
* 34137999 that can be obtained as follows;
* <p>
* long lH = h * 60 * 60 * 1000; //hour to milli
* <p>
* long lM = m * 60 * 1000; // minute to milli
* <p>
* long lS = s * 1000; //seconds to milli
* <p>
* millis = lH + lM + lS + ms;
* @return a string formatted as HH:MM:SS:MSMS i.e. "23:59:59:999"
*/
private static String milliToString(long millis) {
long hrs = TimeUnit.MILLISECONDS.toHours(millis) % 24;
long min = TimeUnit.MILLISECONDS.toMinutes(millis) % 60;
long sec = TimeUnit.MILLISECONDS.toSeconds(millis) % 60;
//millis = millis - (hrs * 60 * 60 * 1000); //alternative way
//millis = millis - (min * 60 * 1000);
//millis = millis - (sec * 1000);
//long mls = millis ;
long mls = millis % 1000;
String toRet = String.format("%02d:%02d:%02d:%03d", hrs, min, sec, mls);
//System.out.println(toRet);
return toRet;
}
}
public String millsToDateFormat(long mills) {
Date date = new Date(mills);
DateFormat formatter = new SimpleDateFormat("HH:mm:ss");
String dateFormatted = formatter.format(date);
return dateFormatted; //note that it will give you the time in GMT+0
}
La réponse marquée comme correcte a une petite erreur,
String myTime = String.format("%02d:%02d:%02d",
TimeUnit.MILLISECONDS.toHours(millis),
TimeUnit.MILLISECONDS.toMinutes(millis) -
TimeUnit.HOURS.toMinutes(TimeUnit.MILLISECONDS.toHours(millis)), // The change is in this line
TimeUnit.MILLISECONDS.toSeconds(millis) -
TimeUnit.MINUTES.toSeconds(TimeUnit.MILLISECONDS.toMinutes(millis)));
par exemple, ceci est un exemple de la valeur que je reçois:
417474:44:19
Voici la solution pour obtenir le bon format:
String myTime = String.format("%02d:%02d:%02d",
//Hours
TimeUnit.MILLISECONDS.toHours(millis) -
TimeUnit.DAYS.toHours(TimeUnit.MILLISECONDS.toDays(millis)),
//Minutes
TimeUnit.MILLISECONDS.toMinutes(millis) -
TimeUnit.HOURS.toMinutes(TimeUnit.MILLISECONDS.toHours(millis)),
//Seconds
TimeUnit.MILLISECONDS.toSeconds(millis) -
TimeUnit.MINUTES.toSeconds(TimeUnit.MILLISECONDS.toMinutes(millis)));
obtenir en conséquence un format correct:
18:44:19
une autre option pour obtenir le format hh:mm:ss est simplement:
Date myDate = new Date(timeinMillis);
SimpleDateFormat formatter = new SimpleDateFormat("HH:mm:ss");
String myTime = formatter.format(myDate);
String string = String.format("%02d:%02d:%02d.%03d",
TimeUnit.MILLISECONDS.toHours(millisecend), TimeUnit.MILLISECONDS.toMinutes(millisecend) - TimeUnit.HOURS.toMinutes(TimeUnit.MILLISECONDS.toHours(millisecend)),
TimeUnit.MILLISECONDS.toSeconds(millisecend) - TimeUnit.MINUTES.toSeconds(TimeUnit.MILLISECONDS.toMinutes(millisecend)), millisecend - TimeUnit.SECONDS.toMillis(TimeUnit.MILLISECONDS.toSeconds(millisecend)));
Format: 00: 00: 00.000
Exemple: 615605 Millisecend
00: 10: 15.605
D'après la réponse de Bohemian, nous n'avons pas besoin d'utiliser TimeUnit pour trouver une valeur connue. Un code beaucoup plus optimal serait
String hms = String.format("%02d:%02d:%02d", millisLeft/(3600*1000),
millisLeft/(60*1000) % 60,
millisLeft/1000 % 60);
J'espère que ça aide
J'ai essayé comme indiqué dans la première réponse. Cela fonctionne, mais moins m'a amené dans la confusion. Ma réponse par Groovy:
import static Java.util.concurrent.TimeUnit.*
...
private static String formatElapsedTime(long millis) {
int hrs = MILLISECONDS.toHours(millis) % 24
int min = MILLISECONDS.toMinutes(millis) % 60
int sec = MILLISECONDS.toSeconds(millis) % 60
int mls = millis % 1000
sprintf( '%02d:%02d:%02d (%03d)', [hrs, min, sec, mls])
}
cela a fonctionné pour moi, avec Kotlin
fun formatToDigitalClock(miliSeconds: Long): String {
val hours = TimeUnit.MILLISECONDS.toHours(miliSeconds).toInt() % 24
val minutes = TimeUnit.MILLISECONDS.toMinutes(miliSeconds).toInt() % 60
val seconds = TimeUnit.MILLISECONDS.toSeconds(miliSeconds).toInt() % 60
return when {
hours > 0 -> String.format("%d:%02d:%02d", hours, minutes, seconds)
minutes > 0 -> String.format("%02d:%02d", minutes, seconds)
seconds > 0 -> String.format("00:%02d", seconds)
else -> {
"00:00"
}
}
}
Java 9
Duration timeLeft = Duration.ofMillis(3600000);
String hhmmss = String.format("%02d:%02d:%02d",
timeLeft.toHours(), timeLeft.toMinutesPart(), timeLeft.toSecondsPart());
System.out.println(hhmmss);
Cela imprime:
01:00:00
Vous faites bien de laisser les méthodes de la bibliothèque effectuer les conversions impliquées pour vous. Java.time, l'API moderne Java date et heure, ou plus précisément, sa classe Duration le fait de manière plus élégante et moins sujette aux erreurs que TimeUnit.
Les méthodes toMinutesPart et toSecondsPart que j'ai utilisées ont été introduites dans Java 9.
Java 6, 7 et 8
long hours = timeLeft.toHours();
timeLeft = timeLeft.minusHours(hours);
long minutes = timeLeft.toMinutes();
timeLeft = timeLeft.minusMinutes(minutes);
long seconds = timeLeft.toSeconds();
String hhmmss = String.format("%02d:%02d:%02d", hours, minutes, seconds);
System.out.println(hhmmss);
La sortie est la même que ci-dessus.
Question: Comment cela peut-il fonctionner dans Java 6 et 7?
- Dans Java 8 et versions ultérieures, ainsi que sur les appareils les plus récents Android (à partir de l'API de niveau 26, _),
Java.timeest intégré. - Dans Java 6 et 7, récupérez ThreeTen Backport, le backport des classes modernes (ThreeTen pour JSR 310; voir les liens en bas).
- Sur (ancien) Android, utilisez l'édition Android de ThreeTen Backport. Il s’appelle ThreeTenABP. Et assurez-vous d’importer les classes de date et d’heure de
org.threeten.bpavec des sous-packages.
Liens
- tutoriel Oracle: Date Time expliquant comment utiliser
Java.time. - demande de spécification Java (JSR) 31 , où
Java.timea été décrit pour la première fois. - projet ThreeTen Backport , le backport de
Java.timeto Java 6 et 7 (ThreeTen pour JSR-310). - ThreeTenABP , Android édition de ThreeTen Backport
- Question: Comment utiliser ThreeTenABP dans Android Project , avec une explication très complète.
Eh bien, vous pouvez essayer quelque chose comme ceci:
public String getElapsedTimeHoursMinutesSecondsString() {
long elapsedTime = getElapsedTime();
String format = String.format("%%0%dd", 2);
elapsedTime = elapsedTime / 1000;
String seconds = String.format(format, elapsedTime % 60);
String minutes = String.format(format, (elapsedTime % 3600) / 60);
String hours = String.format(format, elapsedTime / 3600);
String time = hours + ":" + minutes + ":" + seconds;
return time;
}
convertir des millisecondes en une valeur de temps
Pour Kotlin
val hours = String.format("%02d", TimeUnit.MILLISECONDS.toHours(milSecs))
val minutes = String.format("%02d",
TimeUnit.MILLISECONDS.toMinutes(milSecs) - TimeUnit.HOURS.toMinutes(TimeUnit.MILLISECONDS.toHours(milSecs)))
val seconds = String.format("%02d",
TimeUnit.MILLISECONDS.toSeconds(milSecs) - TimeUnit.MINUTES.toSeconds(TimeUnit.MILLISECONDS.toMinutes(milSecs)))
où, milSecs est en millisecondes