¿Convertir el valor de segundos a horas, minutos, segundos?

He estado intentando convertir un valor de segundos (en una variable BigDecimal) a una cadena en un editText como "1 hora 22 minutos 33 segundos" o algo por el estilo.

He probado 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 trato de 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 configuré el editText en sequnceCaptureTime String. Pero eso no funcionó. Fuerza el cierre de la aplicación cada vez. Estoy totalmente fuera de mi alcance aquí, cualquier ayuda es muy apreciada. ¡Feliz codificación!

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 eliminará los valores decimales después de cada división.

Editar: Si eso no funcionó, intente esto. (Solo lo escribí y lo probé)

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 utilizar un BigDecimal? Si no es necesario, usaría un int o long por segundos, y simplificaría un poco las cosas:

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 sean 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 TimeUnit incorporada 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

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

Si quieres las unidades h, miny secpor un tiempo puedes usar esto:

public static 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);

Son muchos 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

Este código está funcionando bien:

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

Una forma agradable y fácil de hacerlo usando GregorianCalendar

Importe estos al 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));

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;           
    }

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));
}

Sé que esto es bastante antiguo pero en Java 8:

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

por solo minutos y segundos usa esto

String.format("%02d:%02d", (seconds / 3600 * 60 + ((seconds % 3600) / 60)), (seconds % 60))

Utilizo esto en Python para convertir un flotador que representa segundos a horas, minutos, segundos y microsegundos. Es razonablemente elegante y útil para convertir a un tipo de fecha y hora a través de strptime para convertir. También podría extenderse 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 un poco difícil 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 encima es exacto!

Con Java 8, puede lograr fácilmente el tiempo en formato String desde largos segundos como,

LocalTime.ofSecondOfDay(86399L)

Aquí, el valor dado es el máximo permitido para convertir (hasta 24 horas) y el resultado será

23:59:59

Ventajas: 1) No es necesario convertir manualmente y agregar 0 para un solo dígito

Contras: trabaja solo hasta 24 horas

Con Java 8, puede alcanzar fácilmente el tiempo en formato LocalTime desde largos segundos como,

LocalTime.ofSecondOfDay(86399L)

Aquí, el valor dado es el máximo permitido para convertir (hasta 24 horas) y el resultado será

23:59:59

Ventajas: 1) No es necesario convertir manualmente y agregar 0 para un solo dígito

Contras: trabaja solo hasta 24 horas

Duración de java.time

    BigDecimal secondsValue = BigDecimal.valueOf(4953);
    if (secondsValue.compareTo(BigDecimal.valueOf(Long.MAX_VALUE)) > 0) {
        System.out.println("Seconds value " + secondsValue + " is out of range");
    } else {
        Duration dur = Duration.ofSeconds(secondsValue.longValueExact());
        long hours = dur.toHours();
        int minutes = dur.toMinutesPart();
        int seconds = dur.toSecondsPart();

        System.out.format("%d hours %d minutes %d seconds%n", hours, minutes, seconds);
    }

El resultado de este fragmento es:

1 horas 22 minutos 33 segundos

Si hubiera habido una fracción de segundo distinta de cero en el BigDecimal este código no habría funcionado tal como está, pero es posible que pueda modificarlo. El código funciona en Java 9 y versiones posteriores. En Java 8, la conversión de Durationhoras, minutos y segundos es un poco más prolija, consulte el enlace en la parte inferior para saber cómo. Le dejo a usted elegir la forma correcta en singular o plural de las palabras ( hora u horas , etc.).

Enlaces

• Tutorial de Oracle: Fecha y hora que explica cómo usar java.time.
• Respuesta de lauhub mostrando la conversión de Durationa días, horas, minutos y segundos en Java 8.