Konwersja wartości sekund na godziny minuty sekundy?

Próbowałem przekonwertować wartość sekund (w zmiennej BigDecimal) na ciąg w editText, taki jak „1 godzina 22 minuty 33 sekundy” lub coś w tym rodzaju.

Próbowałem tego:

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

(Mam roundThreeCalc, która jest wartością w sekundach, więc próbuję ją tutaj przekonwertować.)

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

Następnie ustawiam editText na ciąg sequnceCaptureTime. Ale to nie zadziałało. Za każdym razem wymuszało to zamknięcie aplikacji. Jestem tutaj całkowicie poza swoją głębią, każda pomoc jest bardzo doceniana. Miłego kodowania!

Powinieneś mieć więcej szczęścia

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

Spowoduje to spadek wartości dziesiętnych po każdym dzieleniu.

Edycja: jeśli to nie zadziałało, spróbuj tego. (Właśnie to napisałem i przetestowałem)

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

Czy konieczne jest użycie BigDecimal? Jeśli nie musisz, użyłbym int lub long przez kilka sekund, co trochę uprościłoby sprawę:

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

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

Możesz jednak chcieć dopełnić każdy, aby upewnić się, że są to wartości dwucyfrowe (lub cokolwiek innego) w ciągu.

DateUtils.formatElapsedTime(long), formatuje upływający czas w postaci „ MM:SS” lub „ H:MM:SS”. Zwraca ciąg, którego szukasz. Dokumentację znajdziesz tutaj

Oto działający kod:

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

Coś naprawdę pomocnego w Javie 8

import java.time.LocalTime;

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

Wolę java wbudowaną w bibliotekę TimeUnit

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;

}

Oto moje proste rozwiązanie:

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

Dlatego lubię upraszczać:

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

Wynik będzie następujący: 01 godzina 23 minuty 20 sekund

Jeśli chcesz jednostki h, mini secprzez pewien czas możesz to wykorzystać:

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

To dużo operatorów warunkowych. Metoda zwróci te ciągi:

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

Ten kod działa poprawnie:

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

Miły i łatwy sposób na zrobienie tego za pomocą GregorianCalendar

Zaimportuj je do projektu:

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

I wtedy:

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

Używam tego:

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

Oto moja funkcja, aby rozwiązać problem:

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

Wiem, że to jest dość stare, ale w Javie 8:

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

przez kilka minut i sekund użyj tego

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

Używam tego w Pythonie do konwersji liczby zmiennoprzecinkowej reprezentującej sekundy na godziny, minuty, sekundy i mikrosekundy. Jest dość elegancki i jest przydatny do konwertowania na typ datetime za pośrednictwem strptime do konwersji. W razie potrzeby można go również łatwo przedłużyć do dłuższych odstępów czasu (tygodnie, miesiące itp.).

    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

Wypróbowałem najlepszy sposób i mniej kodu, ale może być trochę trudno zrozumieć, jak napisałem swój kod, ale jeśli jesteś dobry z matematyki, jest to takie łatwe

import java.util.Scanner;

godziny zajęć {

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





}

}

więcej ponad to jest dokładne!

Dzięki Java 8 możesz łatwo uzyskać czas w formacie String z długich sekund, takich jak,

LocalTime.ofSecondOfDay(86399L)

Tutaj podana wartość jest maksymalna do konwersji (do 24 godzin) i wynik będzie

23:59:59

Zalety: 1) Nie ma potrzeby ręcznej konwersji i dodawania 0 dla pojedynczej cyfry

Wady: pracuj tylko do 24 godzin

Dzięki Java 8 możesz łatwo uzyskać czas w formacie LocalTime z długich sekund, takich jak

LocalTime.ofSecondOfDay(86399L)

Tutaj podana wartość jest maksymalna do konwersji (do 24 godzin) i wynik będzie

23:59:59

Zalety: 1) Nie ma potrzeby ręcznej konwersji i dodawania 0 dla pojedynczej cyfry

Wady: pracuj tylko do 24 godzin

Czas trwania od 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);
    }

Wynik z tego fragmentu kodu to:

1 godzina 22 minuty 33 sekundy

Gdyby w BigDecimalkodzie znajdował się niezerowy ułamek sekundy, kod nie działałby tak, jak jest, ale możesz go zmodyfikować. Kod działa w Javie 9 i nowszych. W Javie 8 konwersja z Durationgodzin, minut i sekund jest nieco bardziej rozwlekła, zobacz link na dole, aby dowiedzieć się, jak to zrobić. Wam pozostawiam wybór poprawnej formy liczby pojedynczej lub mnogiej słów ( godzina lub godziny itp.).

Spinki do mankietów

• Kurs Oracle: Date Time wyjaśniający, jak używać java.time.
• Odpowiedz przez lauhub pokazując konwersję z Durationdni, godzin, minut i sekund w Javie 8.