Convertir segundos valor a horas minutos segundos?

He intentado convertir un valor de segundos (en una variable BigDecimal) en una cadena en un texto de edición como “1 hora 22 minutos 33 segundos” o algo por el estilo.

He intentado esto:

String sequenceCaptureTime = ""; BigDecimal roundThreeCalc = new BigDecimal("0"); BigDecimal hours = new BigDecimal("0"); BigDecimal myremainder = new BigDecimal("0"); BigDecimal minutes = new BigDecimal("0"); BigDecimal seconds = new BigDecimal("0"); BigDecimal var3600 = new BigDecimal("3600"); BigDecimal var60 = new BigDecimal("60"); 

(Tengo un roundThreeCalc que es el valor en segundos, así que bash convertirlo aquí).

 hours = (roundThreeCalc.divide(var3600)); myremainder = (roundThreeCalc.remainder(var3600)); minutes = (myremainder.divide(var60)); seconds = (myremainder.remainder(var60)); sequenceCaptureTime = hours.toString() + minutes.toString() + seconds.toString(); 

Luego configuro EditText a sequnceCaptureTime String. Pero eso no funcionó. Obliga a cerrar la aplicación todo el tiempo. Estoy totalmente fuera de mi scope aquí, cualquier ayuda es muy apreciada. Feliz encoding!

Deberías tener más suerte con

 hours = roundThreeCalc.divide(var3600, BigDecimal.ROUND_FLOOR); myremainder = roundThreeCalc.remainder(var3600); minutes = myremainder.divide(var60, BigDecimal.ROUND_FLOOR); seconds = myremainder.remainder(var60); 

Esto reducirá los valores decimales después de cada división.

Editar: si eso no funcionó, prueba esto. (Acabo de escribir y probarlo)

 public static int[] splitToComponentTimes(BigDecimal biggy) { long longVal = biggy.longValue(); int hours = (int) longVal / 3600; int remainder = (int) longVal - hours * 3600; int mins = remainder / 60; remainder = remainder - mins * 60; int secs = remainder; int[] ints = {hours , mins , secs}; return ints; } 

¿Es necesario usar un BigDecimal? Si no es necesario, usaría un int o long por segundos, y simplificaría las cosas un poco:

 hours = totalSecs / 3600; minutes = (totalSecs % 3600) / 60; seconds = totalSecs % 60; timeString = String.format("%02d:%02d:%02d", hours, minutes, seconds); 

Sin embargo, es posible que desee rellenar cada uno para asegurarse de que son valores de dos dígitos (o lo que sea) en la cadena.

DateUtils.formatElapsedTime(long) , formatea un tiempo transcurrido en la forma ” MM:SS ” o ” H:MM:SS “. Devuelve la cadena que está buscando. Puedes encontrar la documentación aquí

Aquí está el código de trabajo:

 private String getDurationString(int seconds) { int hours = seconds / 3600; int minutes = (seconds % 3600) / 60; seconds = seconds % 60; return twoDigitString(hours) + " : " + twoDigitString(minutes) + " : " + twoDigitString(seconds); } private String twoDigitString(int number) { if (number == 0) { return "00"; } if (number / 10 == 0) { return "0" + number; } return String.valueOf(number); } 

Algo realmente útil en Java 8

 import java.time.LocalTime; private String ConvertSecondToHHMMSSString(int nSecondTime) { return LocalTime.MIN.plusSeconds(nSecondTime).toString(); } 

Prefiero la biblioteca incorporada en TimeUnit de Java

 long seconds = TimeUnit.MINUTES.toSeconds(8); 
 private String ConvertSecondToHHMMString(int secondtTime) { TimeZone tz = TimeZone.getTimeZone("UTC"); SimpleDateFormat df = new SimpleDateFormat("HH:mm:ss"); df.setTimeZone(tz); String time = df.format(new Date(secondtTime*1000L)); return time; } 

Esta es mi solución simple:

 String secToTime(int sec) { int seconds = sec % 60; int minutes = sec / 60; if (minutes >= 60) { int hours = minutes / 60; minutes %= 60; if( hours >= 24) { int days = hours / 24; return String.format("%d days %02d:%02d:%02d", days,hours%24, minutes, seconds); } return String.format("%02d:%02d:%02d", hours, minutes, seconds); } return String.format("00:%02d:%02d", minutes, seconds); } 

Test Results :

 Result: 00:00:36 - 36 Result: 01:00:07 - 3607 Result: 6313 days 12:39:05 - 545488745 

Aquí está mi función para abordar el problema:

 public static String getConvertedTime(double time){ double h,m,s,mil; mil = time % 1000; s = time/1000; m = s/60; h = m/60; s = s % 60; m = m % 60; h = h % 24; return ((int)h < 10 ? "0"+String.valueOf((int)h) : String.valueOf((int)h))+":"+((int)m < 10 ? "0"+String.valueOf((int)m) : String.valueOf((int)m)) +":"+((int)s < 10 ? "0"+String.valueOf((int)s) : String.valueOf((int)s)) +":"+((int)mil > 100 ? String.valueOf((int)mil) : (int)mil > 9 ? "0"+String.valueOf((int)mil) : "00"+String.valueOf((int)mil)); } 

Este código funciona bien:

 txtTimer.setText(String.format("%02d:%02d:%02d",(SecondsCounter/3600), ((SecondsCounter % 3600)/60), (SecondsCounter % 60))); 

Yo uso esto:

  public String SEG2HOR( long lnValue) { //OK String lcStr = "00:00:00"; String lcSign = (lnValue>=0 ? " " : "-"); lnValue = lnValue * (lnValue>=0 ? 1 : -1); if (lnValue>0) { long lnHor = (lnValue/3600); long lnHor1 = (lnValue % 3600); long lnMin = (lnHor1/60); long lnSec = (lnHor1 % 60); lcStr = lcSign + ( lnHor < 10 ? "0": "") + String.valueOf(lnHor) +":"+ ( lnMin < 10 ? "0": "") + String.valueOf(lnMin) +":"+ ( lnSec < 10 ? "0": "") + String.valueOf(lnSec) ; } return lcStr; } 

Me gusta mantener las cosas simples por lo tanto:

  int tot_seconds = 5000; int hours = tot_seconds / 3600; int minutes = (tot_seconds % 3600) / 60; int seconds = tot_seconds % 60; String timeString = String.format("%02d Hour %02d Minutes %02d Seconds ", hours, minutes, seconds); System.out.println(timeString); 

El resultado será: 01 hora 23 minutos 20 segundos

Sé que esto es bastante viejo, pero en java 8:

 LocalTime.MIN.plusSeconds(120).format(DateTimeFormatter.ISO_LOCAL_TIME) 

Una manera fácil y fácil de hacerlo usando GregorianCalendar

Importar estos en el proyecto:

 import java.util.GregorianCalendar; import java.util.Date; import java.text.SimpleDateFormat; import java.util.Scanner; 

Y entonces:

 Scanner s = new Scanner(System.in); System.out.println("Seconds: "); int secs = s.nextInt(); GregorianCalendar cal = new GregorianCalendar(0,0,0,0,0,secs); Date dNow = cal.getTime(); SimpleDateFormat ft = new SimpleDateFormat("HH 'hours' mm 'minutes' ss 'seconds'"); System.out.println("Your time: " + ft.format(dNow)); 

Si quieres las unidades h , min y sec para una duración, puedes usar esto:

 String convertSeconds(int seconds) int h = seconds/ 3600; int m = (seconds % 3600) / 60; int s = seconds % 60; String sh = (h > 0 ? String.valueOf(h) + " " + "h" : ""); String sm = (m < 10 && m > 0 && h > 0 ? "0" : "") + (m > 0 ? (h > 0 && s == 0 ? String.valueOf(m) : String.valueOf(m) + " " + "min") : ""); String ss = (s == 0 && (h > 0 || m > 0) ? "" : (s < 10 && (h > 0 || m > 0) ? "0" : "") + String.valueOf(s) + " " + "sec"); return sh + (h > 0 ? " " : "") + sm + (m > 0 ? " " : "") + ss; } int seconds = 3661; String duration = convertSeconds(seconds); 

Eso es un montón de operadores condicionales. El método devolverá esas cadenas:

 0 -> 0 sec 5 -> 5 sec 60 -> 1 min 65 -> 1 min 05 sec 3600 -> 1 h 3601 -> 1 h 01 sec 3660 -> 1 h 01 3661 -> 1 h 01 min 01 sec 108000 -> 30 h 

Utilizo esto en python para convertir un flotante que representa segundos a horas, minutos, segundos y microsegundos. Es razonablemente elegante y es útil para convertir a un tipo de fecha y hora a través de strptime para convertir. También se puede extender fácilmente a intervalos más largos (semanas, meses, etc.) si es necesario.

  def sectohmsus(seconds): x = seconds hmsus = [] for i in [3600, 60, 1]: # seconds in a hour, minute, and second hmsus.append(int(x / i)) x %= i hmsus.append(int(round(x * 1000000))) # microseconds return hmsus # hours, minutes, seconds, microsecond 

He intentado de la mejor manera y con menos código pero puede ser que sea un poco difícil de entender cómo escribí mi código, pero si eres bueno en matemáticas, es muy fácil

 import java.util.Scanner; 

horas de clase {

 public static void main(String[] args) { Scanner input = new Scanner(System.in); double s; System.out.println("how many second you have "); s =input.nextInt(); double h=s/3600; int h2=(int)h; double h_h2=h-h2; double m=h_h2*60; int m1=(int)m; double m_m1=m-m1; double m_m1s=m_m1*60; System.out.println(h2+" hours:"+m1+" Minutes:"+Math.round(m_m1s)+" seconds"); } 

}

¡más sobre esto es exacto!