Come convertire Milliseconds in “X minuti, x secondi” in Java?

Voglio registrare l’ora utilizzando System.currentTimeMillis() quando un utente inizia qualcosa nel mio programma. Al termine, sottrai l’attuale System.currentTimeMillis() dalla variabile start e voglio mostrare loro il tempo trascorso utilizzando un formato leggibile come “XX ore, XX minuti, XX secondi” o anche “XX minuti” , XX secondi “perché non è probabile che duri a qualcuno un’ora.

Qual’è il miglior modo per farlo?

Utilizzare la class java.util.concurrent.TimeUnit :

 String.format("%d min, %d sec", TimeUnit.MILLISECONDS.toMinutes(millis), TimeUnit.MILLISECONDS.toSeconds(millis) - TimeUnit.MINUTES.toSeconds(TimeUnit.MILLISECONDS.toMinutes(millis)) ); 

Nota: TimeUnit fa parte della specifica Java 1.5, ma toMinutes stato aggiunto a partire da Java 1.6.

Per aggiungere uno zero iniziale per i valori 0-9, fai semplicemente:

 String.format("%02d min, %02d sec", TimeUnit.MILLISECONDS.toMinutes(millis), TimeUnit.MILLISECONDS.toSeconds(millis) - TimeUnit.MINUTES.toSeconds(TimeUnit.MILLISECONDS.toMinutes(millis)) ); 

Se TimeUnit o toMinutes non sono supportati (come su Android prima dell’API versione 9), utilizzare le seguenti equazioni:

 int seconds = (int) (milliseconds / 1000) % 60 ; int minutes = (int) ((milliseconds / (1000*60)) % 60); int hours = (int) ((milliseconds / (1000*60*60)) % 24); //etc... 

Sulla base della risposta di @ siddhadev, ho scritto una funzione che converte millisecondi in una stringa formattata:

  /** * Convert a millisecond duration to a string format * * @param millis A duration to convert to a string form * @return A string of the form "X Days Y Hours Z Minutes A Seconds". */ public static String getDurationBreakdown(long millis) { if(millis < 0) { throw new IllegalArgumentException("Duration must be greater than zero!"); } long days = TimeUnit.MILLISECONDS.toDays(millis); millis -= TimeUnit.DAYS.toMillis(days); long hours = TimeUnit.MILLISECONDS.toHours(millis); millis -= TimeUnit.HOURS.toMillis(hours); long minutes = TimeUnit.MILLISECONDS.toMinutes(millis); millis -= TimeUnit.MINUTES.toMillis(minutes); long seconds = TimeUnit.MILLISECONDS.toSeconds(millis); StringBuilder sb = new StringBuilder(64); sb.append(days); sb.append(" Days "); sb.append(hours); sb.append(" Hours "); sb.append(minutes); sb.append(" Minutes "); sb.append(seconds); sb.append(" Seconds"); return(sb.toString()); } 
 long time = 1536259; return (new SimpleDateFormat("mm:ss:SSS")).format(new Date(time)); 

stampe:

25: 36: 259

Uhm … quanti millisecondi ci sono in un secondo? E in un minuto? La divisione non è così difficile.

 int seconds = (int) ((milliseconds / 1000) % 60); int minutes = (int) ((milliseconds / 1000) / 60); 

Continua così per ore, giorni, settimane, mesi, anni, decenni, qualunque cosa.

Utilizzando il pacchetto java.time in Java 8:

 Instant start = Instant.now(); Thread.sleep(63553); Instant end = Instant.now(); System.out.println(Duration.between(start, end)); 

L’uscita è in formato ISO 8601 Durata : PT1M3.553S (1 minuto e 3.553 secondi).

Non vorrei aggiungere la dipendenza extra solo per quello (la divisione non è poi così difficile, dopotutto), ma se stai usando Commons Lang comunque, ci sono i DurationFormatUtils .

Entrambe le divisioni a mano o utilizzare l’ API SimpleDateFormat .

 long start = System.currentTimeMillis(); // do your work... long elapsed = System.currentTimeMillis() - start; DateFormat df = new SimpleDateFormat("HH 'hours', mm 'mins,' ss 'seconds'"); df.setTimeZone(TimeZone.getTimeZone("GMT+0")); System.out.println(df.format(new Date(elapsed))); 

Modifica di Bombe : è stato mostrato nei commenti che questo approccio funziona solo per durate più piccole (cioè meno di un giorno).

Solo per aggiungere ulteriori informazioni se si desidera formattare come: HH: mm: ss

0 < = HH <= infinito

0 < = mm <60

0 < = ss <60

Usa questo:

 int h = (int) ((startTimeInMillis / 1000) / 3600); int m = (int) (((startTimeInMillis / 1000) / 60) % 60); int s = (int) ((startTimeInMillis / 1000) % 60); 

Ho appena avuto questo problema ora e ho capito

Penso che il modo migliore sia:

 String.format("%d min, %d sec", TimeUnit.MILLISECONDS.toSeconds(length)/60, TimeUnit.MILLISECONDS.toSeconds(length) % 60 ); 

La soluzione più corta:

Qui è probabilmente il più breve che si occupa anche di fusi orari.

 System.out.printf("%tT", millis-TimeZone.getDefault().getRawOffset()); 

Quali uscite ad esempio:

 00:18:32 

Spiegazione:

%tT è l’ora formattata per l’orologio a 24 ore come %tH:%tM:%tS .

%tT accetta anche long come input, quindi non è necessario creare una Date . printf() stamperà semplicemente il tempo specificato in millisecondi, ma nel fuso orario corrente quindi dobbiamo sottrarre l’offset grezzo del fuso orario corrente in modo che 0 millisecondi saranno 0 ore e non il valore di offset orario del fuso orario corrente .

Nota 1: se hai bisogno del risultato come una String , puoi ottenerla in questo modo:

 String t = String.format("%tT", millis-TimeZone.getDefault().getRawOffset()); 

Nota n. 2: fornisce risultati corretti solo se millis è inferiore a un giorno perché la parte del giorno non è inclusa nell’output.

Joda-Time

Usando Joda-Time :

 DateTime startTime = new DateTime(); // do something DateTime endTime = new DateTime(); Duration duration = new Duration(startTime, endTime); Period period = duration.toPeriod().normalizedStandard(PeriodType.time()); System.out.println(PeriodFormat.getDefault().print(period)); 

per Android sotto l’API 9

 (String.format("%d hr %d min, %d sec", millis/(1000*60*60), (millis%(1000*60*60))/(1000*60), ((millis%(1000*60*60))%(1000*60))/1000)) 

Rivisitando il contributo di @ brent-nash, potremmo usare la funzione modulo invece delle sottrazioni e usare il metodo String.format per la stringa risultante:

  /** * Convert a millisecond duration to a string format * * @param millis A duration to convert to a string form * @return A string of the form "X Days Y Hours Z Minutes A Seconds B Milliseconds". */ public static String getDurationBreakdown(long millis) { if (millis < 0) { throw new IllegalArgumentException("Duration must be greater than zero!"); } long days = TimeUnit.MILLISECONDS.toDays(millis); long hours = TimeUnit.MILLISECONDS.toHours(millis) % 24; long minutes = TimeUnit.MILLISECONDS.toMinutes(millis) % 60; long seconds = TimeUnit.MILLISECONDS.toSeconds(millis) % 60; long milliseconds = millis % 1000; return String.format("%d Days %d Hours %d Minutes %d Seconds %d Milliseconds", days, hours, minutes, seconds, milliseconds); } 

Per tempi piccoli, meno di un’ora, preferisco:

 long millis = ... System.out.printf("%1$TM:%1$TS", millis); // or String str = String.format("%1$TM:%1$TS", millis); 

per intervalli più lunghi:

 private static final long HOUR = TimeUnit.HOURS.toMillis(1); ... if (millis < HOUR) { System.out.printf("%1$TM:%1$TS%n", millis); } else { System.out.printf("%d:%2$TM:%2$TS%n", millis / HOUR, millis % HOUR); } 
  long startTime = System.currentTimeMillis(); // do your work... long endTime=System.currentTimeMillis(); long diff=endTime-startTime; long hours=TimeUnit.MILLISECONDS.toHours(diff); diff=diff-(hours*60*60*1000); long min=TimeUnit.MILLISECONDS.toMinutes(diff); diff=diff-(min*60*1000); long seconds=TimeUnit.MILLISECONDS.toSeconds(diff); //hour, min and seconds variables contains the time elapsed on your work 

Il mio semplice calcolo:

 String millisecToTime(int millisec) { int sec = millisec/1000; int second = sec % 60; int minute = sec / 60; if (minute >= 60) { int hour = minute / 60; minute %= 60; return hour + ":" + (minute < 10 ? "0" + minute : minute) + ":" + (second < 10 ? "0" + second : second); } return minute + ":" + (second < 10 ? "0" + second : second); } 

Felice codifica 🙂

Ecco una risposta basata sulla risposta di Brent Nash, Hope that helps!

 public static String getDurationBreakdown(long millis) { String[] units = {" Days ", " Hours ", " Minutes ", " Seconds "}; Long[] values = new Long[units.length]; if(millis < 0) { throw new IllegalArgumentException("Duration must be greater than zero!"); } values[0] = TimeUnit.MILLISECONDS.toDays(millis); millis -= TimeUnit.DAYS.toMillis(values[0]); values[1] = TimeUnit.MILLISECONDS.toHours(millis); millis -= TimeUnit.HOURS.toMillis(values[1]); values[2] = TimeUnit.MILLISECONDS.toMinutes(millis); millis -= TimeUnit.MINUTES.toMillis(values[2]); values[3] = TimeUnit.MILLISECONDS.toSeconds(millis); StringBuilder sb = new StringBuilder(64); boolean startPrinting = false; for(int i = 0; i < units.length; i++){ if( !startPrinting && values[i] != 0) startPrinting = true; if(startPrinting){ sb.append(values[i]); sb.append(units[i]); } } return(sb.toString()); } 

Questo è più facile in Java 9:

  Duration elapsedTime = Duration.ofMillis(millisDiff ); String humanReadableElapsedTime = String.format( "%d hours, %d mins, %d seconds", elapsedTime.toHours(), elapsedTime.toMinutesPart(), elapsedTime.toSecondsPart()); 

Questo produce una stringa come 0 hours, 39 mins, 9 seconds .

Se vuoi arrotondare per interi secondi prima della formattazione:

  elapsedTime = elapsedTime.plusMillis(500).truncatedTo(ChronoUnit.SECONDS); 

Lasciare fuori le ore se sono 0:

  long hours = elapsedTime.toHours(); String humanReadableElapsedTime; if (hours == 0) { humanReadableElapsedTime = String.format( "%d mins, %d seconds", elapsedTime.toMinutesPart(), elapsedTime.toSecondsPart()); } else { humanReadableElapsedTime = String.format( "%d hours, %d mins, %d seconds", hours, elapsedTime.toMinutesPart(), elapsedTime.toSecondsPart()); } 

Ora possiamo avere per esempio 39 mins, 9 seconds .

Per stampare minuti e secondi con zero iniziale per renderli sempre a due cifre, basta inserire 02 negli specificatori di formato rilevanti, quindi:

  String humanReadableElapsedTime = String.format( "%d hours, %02d mins, %02d seconds", elapsedTime.toHours(), elapsedTime.toMinutesPart(), elapsedTime.toSecondsPart()); 

Ora possiamo avere per esempio 0 hours, 39 mins, 09 seconds .

Se sai che la differenza di fuso orario sarebbe inferiore a un’ora, puoi utilizzare il seguente codice:

  Calendar c1 = Calendar.getInstance(); Calendar c2 = Calendar.getInstance(); c2.add(Calendar.MINUTE, 51); long diff = c2.getTimeInMillis() - c1.getTimeInMillis(); c2.set(Calendar.MINUTE, 0); c2.set(Calendar.HOUR, 0); c2.set(Calendar.SECOND, 0); DateFormat df = new SimpleDateFormat("mm:ss"); long diff1 = c2.getTimeInMillis() + diff; System.out.println(df.format(new Date(diff1))); 

Risulterà a: 51:00

Questa risposta è simile ad alcune risposte sopra. Tuttavia, ritengo che sarebbe utile perché, a differenza di altre risposte, rimuoverà qualsiasi virgola o spazio extra e gestirà l’abbreviazione.

 /** * Converts milliseconds to "x days, x hours, x mins, x secs" * * @param millis * The milliseconds * @param longFormat * {@code true} to use "seconds" and "minutes" instead of "secs" and "mins" * @return A string representing how long in days/hours/minutes/seconds millis is. */ public static String millisToString(long millis, boolean longFormat) { if (millis < 1000) { return String.format("0 %s", longFormat ? "seconds" : "secs"); } String[] units = { "day", "hour", longFormat ? "minute" : "min", longFormat ? "second" : "sec" }; long[] times = new long[4]; times[0] = TimeUnit.DAYS.convert(millis, TimeUnit.MILLISECONDS); millis -= TimeUnit.MILLISECONDS.convert(times[0], TimeUnit.DAYS); times[1] = TimeUnit.HOURS.convert(millis, TimeUnit.MILLISECONDS); millis -= TimeUnit.MILLISECONDS.convert(times[1], TimeUnit.HOURS); times[2] = TimeUnit.MINUTES.convert(millis, TimeUnit.MILLISECONDS); millis -= TimeUnit.MILLISECONDS.convert(times[2], TimeUnit.MINUTES); times[3] = TimeUnit.SECONDS.convert(millis, TimeUnit.MILLISECONDS); StringBuilder s = new StringBuilder(); for (int i = 0; i < 4; i++) { if (times[i] > 0) { s.append(String.format("%d %s%s, ", times[i], units[i], times[i] == 1 ? "" : "s")); } } return s.toString().substring(0, s.length() - 2); } /** * Converts milliseconds to "x days, x hours, x mins, x secs" * * @param millis * The milliseconds * @return A string representing how long in days/hours/mins/secs millis is. */ public static String millisToString(long millis) { return millisToString(millis, false); } 

Ho coperto questo in un’altra risposta, ma puoi fare:

 public static Map computeDiff(Date date1, Date date2) { long diffInMillies = date2.getTime() - date1.getTime(); List units = new ArrayList(EnumSet.allOf(TimeUnit.class)); Collections.reverse(units); Map result = new LinkedHashMap(); long milliesRest = diffInMillies; for ( TimeUnit unit : units ) { long diff = unit.convert(milliesRest,TimeUnit.MILLISECONDS); long diffInMilliesForUnit = unit.toMillis(diff); milliesRest = milliesRest - diffInMilliesForUnit; result.put(unit,diff); } return result; } 

L’output è simile a Map:{DAYS=1, HOURS=3, MINUTES=46, SECONDS=40, MILLISECONDS=0, MICROSECONDS=0, NANOSECONDS=0} , con le unità ordinate.

Spetta a te capire come internazionalizzare questi dati in base alle impostazioni locali di destinazione.

Utilizza java.util.concurrent.TimeUnit e utilizza questo semplice metodo:

 private static long timeDiff(Date date, Date date2, TimeUnit unit) { long milliDiff=date2.getTime()-date.getTime(); long unitDiff = unit.convert(milliDiff, TimeUnit.MILLISECONDS); return unitDiff; } 

Per esempio:

 SimpleDateFormat sdf = new SimpleDateFormat("yy/MM/dd HH:mm:ss"); Date firstDate = sdf.parse("06/24/2017 04:30:00"); Date secondDate = sdf.parse("07/24/2017 05:00:15"); Date thirdDate = sdf.parse("06/24/2017 06:00:15"); System.out.println("days difference: "+timeDiff(firstDate,secondDate,TimeUnit.DAYS)); System.out.println("hours difference: "+timeDiff(firstDate,thirdDate,TimeUnit.HOURS)); System.out.println("minutes difference: "+timeDiff(firstDate,thirdDate,TimeUnit.MINUTES)); System.out.println("seconds difference: "+timeDiff(firstDate,thirdDate,TimeUnit.SECONDS)); 

per le stringhe corrette (“1ora, 3 secondi”, “3 minuti” ma non “0 ore, 0 minuti, 3 secondi”) scrivo questo codice:

 int seconds = (int)(millis / 1000) % 60 ; int minutes = (int)((millis / (1000*60)) % 60); int hours = (int)((millis / (1000*60*60)) % 24); int days = (int)((millis / (1000*60*60*24)) % 365); int years = (int)(millis / 1000*60*60*24*365); ArrayList timeArray = new ArrayList(); if(years > 0) timeArray.add(String.valueOf(years) + "y"); if(days > 0) timeArray.add(String.valueOf(days) + "d"); if(hours>0) timeArray.add(String.valueOf(hours) + "h"); if(minutes>0) timeArray.add(String.valueOf(minutes) + "min"); if(seconds>0) timeArray.add(String.valueOf(seconds) + "sec"); String time = ""; for (int i = 0; i < timeArray.size(); i++) { time = time + timeArray.get(i); if (i != timeArray.size() - 1) time = time + ", "; } if (time == "") time = "0 sec"; 

Ho modificato la risposta di @MyKuLLSKI e ho aggiunto il supporto alla plurlizzazione. Ho tolto i secondi perché non avevo bisogno di loro, ma sentitevi liberi di aggiungerlo nuovamente se ne avete bisogno.

 public static String intervalToHumanReadableTime(int intervalMins) { if(intervalMins < = 0) { return "0"; } else { long intervalMs = intervalMins * 60 * 1000; long days = TimeUnit.MILLISECONDS.toDays(intervalMs); intervalMs -= TimeUnit.DAYS.toMillis(days); long hours = TimeUnit.MILLISECONDS.toHours(intervalMs); intervalMs -= TimeUnit.HOURS.toMillis(hours); long minutes = TimeUnit.MILLISECONDS.toMinutes(intervalMs); StringBuilder sb = new StringBuilder(12); if (days >= 1) { sb.append(days).append(" day").append(pluralize(days)).append(", "); } if (hours >= 1) { sb.append(hours).append(" hour").append(pluralize(hours)).append(", "); } if (minutes >= 1) { sb.append(minutes).append(" minute").append(pluralize(minutes)); } else { sb.delete(sb.length()-2, sb.length()-1); } return(sb.toString()); } } public static String pluralize(long val) { return (Math.round(val) > 1 ? "s" : ""); }