Convertire il valore dei secondi in ore minuti secondi?

Ho provato a convertire un valore di secondi (in una variabile BigDecimal) in una stringa in un editText come "1 ora 22 minuti 33 secondi" o qualcosa del genere.

Ho provato questo:

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

(Ho un roundThreeCalc che è il valore in secondi, quindi provo a convertirlo qui.)

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

Quindi ho impostato editText su sequnceCaptureTime String. Ma non ha funzionato. Forza la chiusura dell'app ogni volta. Sono totalmente fuori dalla mia profondità qui, qualsiasi aiuto è molto apprezzato. Buona programmazione!

Dovresti avere più fortuna con

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

Questo farà cadere i valori decimali dopo ogni divisione.

Modifica: se non ha funzionato, prova questo. (L'ho appena scritto e testato)

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

È necessario utilizzare un BigDecimal? Se non è necessario, userei un int o long per secondi e semplificherebbe un po 'le cose:

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

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

Tuttavia, potresti voler riempire ciascuno per assicurarti che siano valori a due cifre (o qualsiasi altra cosa) nella stringa.

DateUtils.formatElapsedTime(long), formatta un tempo trascorso nel formato " MM:SS" o " H:MM:SS". Restituisce la stringa che stai cercando. Puoi trovare la documentazione qui

Ecco il codice di lavoro:

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

Qualcosa di veramente utile in Java 8

import java.time.LocalTime;

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

Preferisco la libreria TimeUnit incorporata di 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;

}

Questa è la mia semplice soluzione:

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

Mi piace mantenere le cose semplici quindi:

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

Il risultato sarà: 01 ora 23 minuti 20 secondi

Se si desidera che le unità h, mine secper una durata è possibile utilizzare questo:

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

Sono molti operatori condizionali. Il metodo restituirà quelle stringhe:

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

Questo codice funziona bene:

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

Un modo semplice e piacevole per farlo usando GregorianCalendar

Importali nel progetto:

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

E poi:

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

Io uso questo:

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

Ecco la mia funzione per affrontare il 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));
}

So che è piuttosto vecchio ma in java 8:

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

per pochi minuti e secondi usa questo

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

Lo uso in Python per convertire un float che rappresenta i secondi in ore, minuti, secondi e microsecondi. È ragionevolmente elegante ed è utile per la conversione in un tipo datetime tramite strptime per convertire. Se necessario, potrebbe anche essere facilmente esteso a intervalli più lunghi (settimane, mesi, ecc.).

    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

ho provato il modo migliore e meno codice ma potrebbe essere un po 'difficile capire come ho scritto il mio codice ma se sei bravo in matematica è così facile

import java.util.Scanner;

ore di lezione {

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





}

}

in più è accurato!

Con Java 8, puoi facilmente ottenere il tempo in formato String da lunghi secondi come,

LocalTime.ofSecondOfDay(86399L)

Qui, il valore dato è massimo consentito per la conversione (fino a 24 ore) e il risultato sarà

23:59:59

Pro: 1) Non è necessario convertire manualmente e aggiungere 0 per una singola cifra

Contro: funziona solo fino a 24 ore

Con Java 8, puoi facilmente ottenere l'ora nel formato LocalTime da lunghi secondi come,

LocalTime.ofSecondOfDay(86399L)

Qui, il valore dato è massimo consentito per la conversione (fino a 24 ore) e il risultato sarà

23:59:59

Pro: 1) Non è necessario convertire manualmente e aggiungere 0 per una singola cifra

Contro: funziona solo fino a 24 ore

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

L'output di questo snippet è:

1 ore 22 minuti 33 secondi

Se ci fosse stata una frazione di secondo diversa da zero in BigDecimalquesto codice non avrebbe funzionato così com'è, ma potresti essere in grado di modificarlo. Il codice funziona in Java 9 e versioni successive. In Java 8 la conversione da Durationin ore minuti e secondi è un po 'più prolissa, vedi il link in basso per sapere come. Lascio a voi la scelta della corretta forma singolare o plurale delle parole ( ora o ore , ecc.).

link

• Tutorial Oracle: Date Time che spiega come utilizzare java.time.
• Risposta di lauhub che mostra la conversione da a Durationa giorni, ore, minuti e secondi in Java 8.