Convertir la valeur des secondes en heures minutes secondes?

J'ai essayé de convertir une valeur de secondes (dans une variable BigDecimal) en une chaîne dans un editText comme "1 heure 22 minutes 33 secondes" ou quelque chose du genre.

J'ai essayé ceci:

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

(J'ai un roundThreeCalc qui est la valeur en secondes donc j'essaye de le convertir ici.)

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

Ensuite, j'ai défini editText sur sequnceCaptureTime String. Mais cela n'a pas fonctionné. Cela force la fermeture de l'application à chaque fois. Je suis totalement hors de ma portée ici, toute aide est grandement appréciée. Bon codage!

Tu devrais avoir plus de chance avec

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

Cela supprimera les valeurs décimales après chaque division.

Edit: Si cela ne fonctionne pas, essayez ceci. (Je viens de l'écrire et de le tester)

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

Est-il nécessaire d'utiliser un BigDecimal? Si vous n'êtes pas obligé, j'utiliserais un int ou long pendant secondes, et cela simplifierait un peu les choses:

hours = totalSecs / 3600;
minutes = (totalSecs % 3600) / 60;
seconds = totalSecs % 60;

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

Vous voudrez peut-être remplir chacun pour vous assurer qu'il s'agit de valeurs à deux chiffres (ou autre) dans la chaîne, cependant.

DateUtils.formatElapsedTime(long), met en forme un temps écoulé sous la forme " MM:SS" ou " H:MM:SS". Il renvoie la chaîne que vous recherchez. Vous pouvez trouver la documentation ici

Voici le code de travail:

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

Quelque chose de vraiment utile dans Java 8

import java.time.LocalTime;

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

Je préfère la bibliothèque TimeUnit intégrée 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;

}

Voici ma solution 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

J'aime garder les choses simples donc:

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

Le résultat sera: 01 heure 23 minutes 20 secondes

Si vous voulez les unités h, minet secpour une durée, vous pouvez utiliser ceci:

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

C'est beaucoup d'opérateurs conditionnels. La méthode retournera ces chaînes:

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

Ce code fonctionne bien:

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

Un moyen simple et agréable de le faire en utilisant GregorianCalendar

Importez-les dans le projet:

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

Puis:

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

J'utilise ceci:

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

Voici ma fonction pour résoudre le problème:

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

Je sais que c'est assez vieux mais en java 8:

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

pendant quelques minutes et secondes utilisez ceci

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

J'utilise ceci en python pour convertir un flottant représentant des secondes en heures, minutes, secondes et microsecondes. C'est raisonnablement élégant et pratique pour la conversion en un type datetime via strptime pour convertir. Il pourrait également être facilement étendu à des intervalles plus longs (semaines, mois, etc.) si nécessaire.

    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

J'ai essayé le meilleur moyen et moins de code, mais c'est peut-être un peu difficile de comprendre comment j'ai écrit mon code, mais si vous êtes bon en maths, c'est si facile

import java.util.Scanner;

heures de cours {

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





}

}

en plus c'est précis!

Avec Java 8, vous pouvez facilement atteindre le temps au format String à partir de longues secondes comme,

LocalTime.ofSecondOfDay(86399L)

Ici, la valeur donnée est maximale autorisée à convertir (jusqu'à 24 heures) et le résultat sera

23:59:59

Avantages: 1) Pas besoin de convertir manuellement et d'ajouter 0 pour un seul chiffre

Inconvénients: ne travaillez que pendant 24 heures maximum

Avec Java 8, vous pouvez facilement atteindre le temps au format LocalTime à partir de longues secondes comme,

LocalTime.ofSecondOfDay(86399L)

Ici, la valeur donnée est maximale autorisée à convertir (jusqu'à 24 heures) et le résultat sera

23:59:59

Avantages: 1) Pas besoin de convertir manuellement et d'ajouter 0 pour un seul chiffre

Inconvénients: ne travaillez que pendant 24 heures maximum

Durée depuis 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);
    }

La sortie de cet extrait de code est:

1 heures 22 minutes 33 secondes

S'il y avait eu une fraction de seconde non nulle dans le BigDecimalcode, ce code n'aurait pas fonctionné tel quel, mais vous pourrez peut-être le modifier. Le code fonctionne dans Java 9 et versions ultérieures. Dans Java 8, la conversion Durationen heures, minutes et secondes est un peu plus verbeuse, voir le lien en bas pour savoir comment. Je vous laisse choisir la bonne forme singulière ou plurielle des mots ( heure ou heures , etc.).

Liens

• Tutoriel Oracle: Date et heure expliquant comment utiliser java.time.
• Réponse de lauhub montrant la conversion de a Durationen jours, heures, minutes et secondes dans Java 8.