मिलीसेकंड को "hh: mm: ss" प्रारूप में कैसे बदलें?

184

मैं उलझन में हूं। इस थ्रेड पर ठोकर खाने के बाद , मैंने यह पता लगाने की कोशिश की कि एक उलटी गिनती टाइमर को कैसे प्रारूपित किया जाए hh:mm:ss।

यहाँ मेरा प्रयास है - 

//hh:mm:ss
String.format("%02d:%02d:%02d", 
    TimeUnit.MILLISECONDS.toHours(millis),
    TimeUnit.MILLISECONDS.toMinutes(millis) - 
    TimeUnit.MINUTES.toMinutes(TimeUnit.MILLISECONDS.toHours(millis)),
    TimeUnit.MILLISECONDS.toSeconds(millis) - 
    TimeUnit.MINUTES.toSeconds(TimeUnit.MILLISECONDS.toMinutes(millis)));

इसलिए, जब मैं जैसे मूल्य की कोशिश करता 3600000msहूं, मुझे मिलता है 01:59:00, जो गलत है क्योंकि यह होना चाहिए 01:00:00। जाहिर है कि मेरे तर्क में कुछ गड़बड़ है, लेकिन फिलहाल, मैं यह नहीं देख सकता कि यह क्या है!

क्या कोई मदद कर सकता है?

संपादित करें -

ठीक कर दिया। यहां मिलिसेकंड को hh:mm:ssप्रारूपित करने का सही तरीका है -

//hh:mm:ss
String.format("%02d:%02d:%02d", 
    TimeUnit.MILLISECONDS.toHours(millis),
    TimeUnit.MILLISECONDS.toMinutes(millis) - 
    TimeUnit.HOURS.toMinutes(TimeUnit.MILLISECONDS.toHours(millis)),
    TimeUnit.MILLISECONDS.toSeconds(millis) - 
    TimeUnit.MINUTES.toSeconds(TimeUnit.MILLISECONDS.toMinutes(millis))));

समस्या यह थी TimeUnit.MINUTES.toMinutes(TimeUnit.MILLISECONDS.toHours(millis))। इसके TimeUnit.HOURS.toMinutes(TimeUnit.MILLISECONDS.toHours(millis))बजाय यह होना चाहिए था ।

java  time-format  countdowntimer 
— MRE
स्रोत
1
3,600,000 मिलीसेकंड 3,600 सेकंड, या 60 मिनट, या 1 घंटा है। यह नहीं होना चाहिए 00:59:59, यह होना चाहिए 01:00:00।
— बोरेलिड

जवाबों:

354

आप वास्तव में करीब थे :

String.format("%02d:%02d:%02d", 
TimeUnit.MILLISECONDS.toHours(millis),
TimeUnit.MILLISECONDS.toMinutes(millis) -  
TimeUnit.HOURS.toMinutes(TimeUnit.MILLISECONDS.toHours(millis)), // The change is in this line
TimeUnit.MILLISECONDS.toSeconds(millis) - 
TimeUnit.MINUTES.toSeconds(TimeUnit.MILLISECONDS.toMinutes(millis)));

आप का उपयोग millisseconds घंटे परिवर्तित कर रहे थे मिनट के बजाय घंटे ।

BTW, मुझे TimeUnitएपीआई का आपका उपयोग पसंद है :)

यहां कुछ परीक्षण कोड दिए गए हैं:

public static void main(String[] args) throws ParseException {
    long millis = 3600000;
    String hms = String.format("%02d:%02d:%02d", TimeUnit.MILLISECONDS.toHours(millis),
            TimeUnit.MILLISECONDS.toMinutes(millis) - TimeUnit.HOURS.toMinutes(TimeUnit.MILLISECONDS.toHours(millis)),
            TimeUnit.MILLISECONDS.toSeconds(millis) - TimeUnit.MINUTES.toSeconds(TimeUnit.MILLISECONDS.toMinutes(millis)));
    System.out.println(hms);
}

आउटपुट:

01:00:00

मैंने महसूस किया कि उपर्युक्त के बजाय एक मापांक विभाजन का उपयोग करके ऊपर दिए गए मेरे कोड को बहुत सरल बनाया जा सकता है:

String hms = String.format("%02d:%02d:%02d", TimeUnit.MILLISECONDS.toHours(millis),
    TimeUnit.MILLISECONDS.toMinutes(millis) % TimeUnit.HOURS.toMinutes(1),
    TimeUnit.MILLISECONDS.toSeconds(millis) % TimeUnit.MINUTES.toSeconds(1));

फिर भी TimeUnitसभी जादू मूल्यों के लिए एपीआई का उपयोग करना , और बिल्कुल समान आउटपुट देता है।

— बोहेमियन
स्रोत
2
आमीन, जिस तरह से आप टाइम यूनीट एपीआई का उपयोग करते हैं :)
— धीरज भास्कर
2
यह पहिया को सुदृढ़ करने के लिए एक अच्छा विचार नहीं है! ट्राइटन मैन का जवाब बेहतर समाधान है।
— محمدباقر
5
@ محمدباقر लेकिन दूसरा उत्तर बाहरी लाइब्रेरी का उपयोग करता है, जबकि मेरा कोड केवल कोर JDK का उपयोग करता है। यह इस बात पर निर्भर करता है कि आपकी ज़रूरतें क्या हैं - उदाहरण के लिए आप बाहरी पुस्तकालय का उपयोग करने में सक्षम नहीं हो सकते हैं। अन्य उत्तर हालांकि अच्छा है।
— बोहेमियन
2
@ ओफ़्फ़ जोड़ें .replaceAll("^00:", "")या .replaceAll("^00:(00:)?", "")मिनटों के साथ ही घंटों को हटा दें यदि दोनों शून्य हैं।
— बोहेमियन
2
@Ozuf आपको "15:00"और "10:00:23"क्रमशः; केवल प्रमुख शून्य हटा दिए जाते हैं, क्योंकि मैच को इनपुट द्वारा शुरू करने के लिए लंगर डाला जाता है ^।
— बोहेमियन
77

इसके लिए सामान्य तरीका काफी सरल है:

public static String convertSecondsToHMmSs(long seconds) {
    long s = seconds % 60;
    long m = (seconds / 60) % 60;
    long h = (seconds / (60 * 60)) % 24;
    return String.format("%d:%02d:%02d", h,m,s);
}
— पैटलिस हैं
स्रोत
1
@ Javaman59, क्या आपका मतलब String.format("% 02 था d:%02d:%02d", h,m,s) ?
— करेनअन
2
@KarenAnne। यह इस बात पर निर्भर करता है कि आप क्या चाहते हैं, उदाहरण के लिए, "03:59:59" या "3:59:59"।
— स्टीफन होकिंग
2
मिलीसेकंड में समय, आपको 1000 से अधिक गुणा करने की आवश्यकता है
— अपूर्वा
5
लेखक ने मिलीसेकंड के बारे में पूछा, सेकंड नहीं!
— user924
59

यदि आप अपाचे कॉमन्स का उपयोग कर रहे हैं:

DurationFormatUtils.formatDuration(timeInMS, "HH:mm:ss,SSS");
— ट्राइटन मैन
स्रोत
4
शॉर्टकट:DurationFormatUtils.formatDurationHMS(timeInMS);
— अरोनियांना
@ जॉर्जीज अप्रचलित क्यों हैं?
— पियोवेज़न
वे अप्रचलित नहीं हैं।
— ट्राइटन मैन
26

मैंने इसका उपयोग किया:

String.format("%1$tH:%1$tM:%1$tS.%1$tL", millis);

वर्ग सूत्र का वर्णन देखें ।

2400 एमएस के इनपुट का उपयोग करके रन करने योग्य उदाहरण देखें ।

— Zulum
स्रोत
यह काम नहीं कर रहा है, मैं इसे केवल 100, 1000, 1200 पास करके देखता हूं और यह 05:30:00 , 05:30:01 , 05:01:01 के रूप में प्रतिक्रिया करता है ।
— CoDe
2
@ कॉड, यह आपके समय क्षेत्र के लिए काम करता है। आपको UTC की तुलना में भिन्न समय क्षेत्र में होना चाहिए। String.format()समय क्षेत्र निर्भर है । हालांकि, आदर्श सही उत्तर, समय क्षेत्र स्वतंत्र होना चाहिए ।
— डेरेक महार
@CoDe, यह आपके टाइम ज़ोन के अनुरूप समय दिखा रहा है जो UTC से भिन्न होना चाहिए। String.format()समय क्षेत्र निर्भर है । हालांकि, आदर्श सही उत्तर, समय क्षेत्र स्वतंत्र होना चाहिए ।
— डेरेक महार
25 
// New date object from millis
Date date = new Date(millis);
// formattter 
SimpleDateFormat formatter= new SimpleDateFormat("HH:mm:ss.SSS");
formatter.setTimeZone(TimeZone.getTimeZone("UTC"));
// Pass date object
String formatted = formatter.format(date );

1200 एमएस के इनपुट का उपयोग करके रन करने योग्य उदाहरण देखें ।

— विनय लोढ़ा
स्रोत
3
यह एक दिन से अधिक समय के लिए गलत परिणाम देगा। यह 23 से 0 से घंटे की संख्या को लपेट देगा, जो शायद यहाँ वांछनीय नहीं है।
— केनस्टर
कोई दोस्त नहीं ... मुझे लगता है कि यह अभी भी वही काम करेगा। आज की तारीख के साथ कोशिश करें
— विनय लोढ़ा
1
SimpleDateFormat sdf = new SimpleDateFormat ("hh: mm aa"); यदि कोई व्यक्ति 12 घंटे के प्रारूप में am / pm
— Ajji
14 
DateFormat df = new SimpleDateFormat("HH:mm:ss");
String formatted = df.format(aDateObject);
— गेब्रियल बेलुंजिएर्स
स्रोत
1
के रूप में ही जवाब stackoverflow.com/questions/9027317/... 1 दिन से ऊपर की अवधि के लिए एक ही समस्या के साथ
— वनवर्ल्ड
यह समय क्षेत्र पर भी निर्भर करता है, जिसका अर्थ है कि परिणाम अलग-अलग समय क्षेत्र में चलने पर भिन्न होगा।
— डेरेक महार
10

4 कार्यान्वयन के लिए परीक्षा परिणाम

विशाल डेटा के लिए बहुत अधिक प्रारूपण करने के बाद, सबसे अच्छे प्रदर्शन की आवश्यकता है, इसलिए यहां (आश्चर्यजनक) परिणाम हैं:

for (int i = 0; मैं <1000000; i ++) {FUNCTION_CALL}

अवधियां:

  • कॉम्बिनेशनफॉर्म: 196 मिली
  • प्रारूप अवधि: 272 मिली
  • apacheFormat: 754 मिली

  • formatTimeUnit: 2216 मिली

    public static String apacheFormat(long millis) throws ParseException {
    return DurationFormatUtils.formatDuration(millis, "HH:mm:ss");
}

public static String formatTimeUnit(long millis) throws ParseException {
String formatted = String.format(
        "%02d:%02d:%02d",
        TimeUnit.MILLISECONDS.toHours(millis),
        TimeUnit.MILLISECONDS.toMinutes(millis)
                - TimeUnit.HOURS.toMinutes(TimeUnit.MILLISECONDS.toHours(millis)),
        TimeUnit.MILLISECONDS.toSeconds(millis)
                - TimeUnit.MINUTES.toSeconds(TimeUnit.MILLISECONDS.toMinutes(millis)));
    return formatted;
}

public static String formatDuration(final long millis) {
    long seconds = (millis / 1000) % 60;
    long minutes = (millis / (1000 * 60)) % 60;
    long hours = millis / (1000 * 60 * 60);

    StringBuilder b = new StringBuilder();
    b.append(hours == 0 ? "00" : hours < 10 ? String.valueOf("0" + hours) : 
    String.valueOf(hours));
    b.append(":");
    b.append(minutes == 0 ? "00" : minutes < 10 ? String.valueOf("0" + minutes) :     
    String.valueOf(minutes));
    b.append(":");
    b.append(seconds == 0 ? "00" : seconds < 10 ? String.valueOf("0" + seconds) : 
    String.valueOf(seconds));
    return b.toString();
}

public static String combinationFormatter(final long millis) {
    long seconds = TimeUnit.MILLISECONDS.toSeconds(millis)
            - TimeUnit.MINUTES.toSeconds(TimeUnit.MILLISECONDS.toMinutes(millis));
    long minutes = TimeUnit.MILLISECONDS.toMinutes(millis)
            - TimeUnit.HOURS.toMinutes(TimeUnit.MILLISECONDS.toHours(millis));
    long hours = TimeUnit.MILLISECONDS.toHours(millis);

    StringBuilder b = new StringBuilder();
    b.append(hours == 0 ? "00" : hours < 10 ? String.valueOf("0" + hours) : 
    String.valueOf(hours));
    b.append(":");
    b.append(minutes == 0 ? "00" : minutes < 10 ? String.valueOf("0" + minutes) : 
    String.valueOf(minutes));
        b.append(":");
    b.append(seconds == 0 ? "00" : seconds < 10 ? String.valueOf("0" + seconds) : 
    String.valueOf(seconds));
    return b.toString(); 
 }
— MariusA
स्रोत
इन जैसे मीट्रिक कितने विश्वसनीय हैं? मैं वास्तव में इस प्रक्रिया को कभी नहीं समझ पाया हूँ।
— 14:11
मेरी स्थिति में जहां उत्तराधिकार में कुछ हजारों वस्तुएं बनती हैं, मुझे लगता है कि यह परीक्षा काफी उपयोगी है। ठीक है बस कुछ तारों को सेट नहीं करना है, लेकिन उन वस्तुओं का निर्माण करना है जिनमें एक फ़ील्ड एक स्वरूपित स्ट्रिंग है।
— मारिसा
@ आप का उपयोग करने के लिए मुसीबत में चला गया, StringBuilderतो "0" + प्रकार की "खंडहर" का उपयोग करने की गलती करें। @ जेवीएम की जीसी बहुत छोटी-छोटी वस्तुओं को आवंटित करने और एकत्र करने में बहुत अच्छी है, कोई चिंता नहीं है। मैं String.formatकिसी भी प्रमुख-शून्य तर्क से निपटने के लिए गया था।
— llc
6

बोहेमियन के जवाब से जाने हमें एक ज्ञात मूल्य खोजने के लिए टाइम यूनीट का उपयोग करने की आवश्यकता नहीं है। बहुत अधिक इष्टतम कोड होगा

String hms = String.format("%02d:%02d:%02d", millisLeft/(3600*1000),
                    millisLeft/(60*1000) % 60,
                    millisLeft/1000 % 60);

आशा करता हूँ की ये काम करेगा

— Aalin
स्रोत
आपके उत्तर की तरह! बस सरल गणित। Btw मेरे मामले में मैं अंत में मिलीसेकंड जोड़ा millisLeft%1000/10तो हम प्रारूप मिलता हैhour:minutes:seconds:milliseconds
— Lê Quang Duy
@ LêQuangDuy मुझे 01: 24: 51,123 जैसे 3 अंकों में मिलीसेकंड की आवश्यकता है, लेकिन आपका 3 आखिर में क्या कर रहा है?
— नानू
@naanu सिर्फ उपयोग करेंmillisLeft%1000
— Lê Quang Duy
6 
 public String millsToDateFormat(long mills) {

    Date date = new Date(mills);
    DateFormat formatter = new SimpleDateFormat("HH:mm:ss");
    String dateFormatted = formatter.format(date);
    return dateFormatted; //note that it will give you the time in GMT+0
}
— सीटीयू
स्रोत
उत्तर समय क्षेत्र पर निर्भर करता है जिसका अर्थ है कि परिणाम अलग-अलग समय क्षेत्र में चलने पर भिन्न होगा।
— डेरेक महार
6

यह मेरे लिए काम करता है, कोटलिन के साथ

fun formatToDigitalClock(miliSeconds: Long): String {
        val hours = TimeUnit.MILLISECONDS.toHours(miliSeconds).toInt() % 24
        val minutes = TimeUnit.MILLISECONDS.toMinutes(miliSeconds).toInt() % 60
        val seconds = TimeUnit.MILLISECONDS.toSeconds(miliSeconds).toInt() % 60
        return when {
            hours > 0 -> String.format("%d:%02d:%02d", hours, minutes, seconds)
            minutes > 0 -> String.format("%02d:%02d", minutes, seconds)
            seconds > 0 -> String.format("00:%02d", seconds)
            else -> {
                "00:00"
            }
        }
    }
— Devix
स्रोत
मेरे लिए पूरी तरह से काम किया। यह सबसे अच्छा उत्तर होना चाहिए क्योंकि यह शून्य घंटे को संभालता है
— vNext
6

जावा ९

    Duration timeLeft = Duration.ofMillis(3600000);
    String hhmmss = String.format("%02d:%02d:%02d", 
            timeLeft.toHours(), timeLeft.toMinutesPart(), timeLeft.toSecondsPart());
    System.out.println(hhmmss);

यह प्रिंट:

01:00:00

आप लाइब्रेरी विधियों को आपके लिए शामिल रूपांतरणों को करने देने में सही कर रहे हैं। java.timeआधुनिक जावा तिथि और समय एपीआई, या अधिक सटीक रूप से, इसकी Durationकक्षा इसे अधिक सुरुचिपूर्ण ढंग से और कम त्रुटि वाले तरीके से करती है TimeUnit।

toMinutesPartऔर toSecondsPartतरीकों मैं इस्तेमाल किया जावा 9 में शुरू किए गए थे।

जावा 6, 7 और 8

    long hours = timeLeft.toHours();
    timeLeft = timeLeft.minusHours(hours);
    long minutes = timeLeft.toMinutes();
    timeLeft = timeLeft.minusMinutes(minutes);
    long seconds = timeLeft.toSeconds();
    String hhmmss = String.format("%02d:%02d:%02d", hours, minutes, seconds);
    System.out.println(hhmmss);

आउटपुट ऊपर जैसा ही है।

प्रश्न: कैसे जावा 6 और 7 में काम कर सकते हैं?

  • जावा 8 और बाद में और नए एंड्रॉइड डिवाइसों पर (एपीआई स्तर 26 से, मुझे बताया गया है) java.timeबिल्ट-इन आता है।
  • जावा 6 और 7 में थ्रीटेन बैकपोर्ट मिलता है, आधुनिक कक्षाओं का बैकपोर्ट (जेएसआर 310 के लिए थ्रीटेन; नीचे की ओर लिंक देखें)।
  • पर (पुराने) एंड्रॉइड, थ्रीटेन बैकपोर्ट के एंड्रॉइड संस्करण का उपयोग करते हैं। इसे थ्रीटेनबप कहा जाता है। और सुनिश्चित करें कि आप org.threeten.bpसबपेकेज से दिनांक और समय की कक्षाओं का आयात करते हैं ।

लिंक

— ओले वी.वी.
स्रोत
5

नीचे दिया गया कोड दोनों तरह से रूपांतरण करता है

23: 59: 58: 999 से 86398999

और से

86398999 से 23: 59: 58: 999

import java.util.concurrent.TimeUnit;

public class TimeUtility {

    public static void main(String[] args) {

        long currentDateTime = System.currentTimeMillis();

        String strTest = "23:59:58:999";
        System.out.println(strTest);

        long l = strToMilli(strTest);
        System.out.println(l);
        l += 1;
        String str = milliToString(l);
        System.out.println(str);
    }

    /**
     * convert a time string into the equivalent long milliseconds
     *
     * @param strTime string fomratted as HH:MM:SS:MSMS i.e. "23:59:59:999"
     * @return long integer like 86399999
     */
    public static long strToMilli(String strTime) {
        long retVal = 0;
        String hour = strTime.substring(0, 2);
        String min = strTime.substring(3, 5);
        String sec = strTime.substring(6, 8);
        String milli = strTime.substring(9, 12);
        int h = Integer.parseInt(hour);
        int m = Integer.parseInt(min);
        int s = Integer.parseInt(sec);
        int ms = Integer.parseInt(milli);

        String strDebug = String.format("%02d:%02d:%02d:%03d", h, m, s, ms);
        //System.out.println(strDebug);
        long lH = h * 60 * 60 * 1000;
        long lM = m * 60 * 1000;
        long lS = s * 1000;

        retVal = lH + lM + lS + ms;
        return retVal;
    }

    /**
     * convert time in milliseconds to the corresponding string, in case of day
     * rollover start from scratch 23:59:59:999 + 1 = 00:00:00:000
     *
     * @param millis the number of milliseconds corresponding to tim i.e.
     *               34137999 that can be obtained as follows;
     *               <p>
     *               long lH = h * 60 * 60 * 1000; //hour to milli
     *               <p>
     *               long lM = m * 60 * 1000; // minute to milli
     *               <p>
     *               long lS = s * 1000; //seconds to milli
     *               <p>
     *               millis = lH + lM + lS + ms;
     * @return a string formatted as HH:MM:SS:MSMS i.e. "23:59:59:999"
     */
    private static String milliToString(long millis) {

        long hrs = TimeUnit.MILLISECONDS.toHours(millis) % 24;
        long min = TimeUnit.MILLISECONDS.toMinutes(millis) % 60;
        long sec = TimeUnit.MILLISECONDS.toSeconds(millis) % 60;
        //millis = millis - (hrs * 60 * 60 * 1000); //alternative way
        //millis = millis - (min * 60 * 1000);
        //millis = millis - (sec * 1000);
        //long mls = millis ;
        long mls = millis % 1000;
        String toRet = String.format("%02d:%02d:%02d:%03d", hrs, min, sec, mls);
        //System.out.println(toRet);
        return toRet;
    }
}
— Menzio Luca Fabrizio
स्रोत
मैंने इस समाधान को उकेरा। बस सेक और mls के बीच एक बिंदु रखो। और मुझे नहीं पता कि जावा में बार और तारीख से निपटना कितना मुश्किल है। सबसे अधिक उपयोग किए जाने वाले फ़ंक्शन पहले से ही उपलब्ध होने चाहिए और कक्षा का हिस्सा होना चाहिए।
— बरूच अट्टा
5 
        String string = String.format("%02d:%02d:%02d.%03d",
            TimeUnit.MILLISECONDS.toHours(millisecend), TimeUnit.MILLISECONDS.toMinutes(millisecend) - TimeUnit.HOURS.toMinutes(TimeUnit.MILLISECONDS.toHours(millisecend)),
            TimeUnit.MILLISECONDS.toSeconds(millisecend) - TimeUnit.MINUTES.toSeconds(TimeUnit.MILLISECONDS.toMinutes(millisecend)), millisecend - TimeUnit.SECONDS.toMillis(TimeUnit.MILLISECONDS.toSeconds(millisecend)));

प्रारूप: 00: 00: 00.000

उदाहरण: 615605 मिलिसेंडेंड

00: 10: 15.605

— ओमिद नाजी
स्रोत
5

सही के रूप में चिह्नित उत्तर में थोड़ी गलती है,

String myTime = String.format("%02d:%02d:%02d",
            TimeUnit.MILLISECONDS.toHours(millis),
            TimeUnit.MILLISECONDS.toMinutes(millis) -
                    TimeUnit.HOURS.toMinutes(TimeUnit.MILLISECONDS.toHours(millis)), // The change is in this line
            TimeUnit.MILLISECONDS.toSeconds(millis) -
                    TimeUnit.MINUTES.toSeconds(TimeUnit.MILLISECONDS.toMinutes(millis)));

उदाहरण के लिए यह उस मूल्य का एक उदाहरण है जो मुझे मिलता है:

417474:44:19

यह सही प्रारूप प्राप्त करने का उपाय है:

String myTime =  String.format("%02d:%02d:%02d",
                //Hours
                TimeUnit.MILLISECONDS.toHours(millis) -
                        TimeUnit.DAYS.toHours(TimeUnit.MILLISECONDS.toDays(millis)),
                //Minutes
                TimeUnit.MILLISECONDS.toMinutes(millis) -
                        TimeUnit.HOURS.toMinutes(TimeUnit.MILLISECONDS.toHours(millis)),
                //Seconds
                TimeUnit.MILLISECONDS.toSeconds(millis) -
                        TimeUnit.MINUTES.toSeconds(TimeUnit.MILLISECONDS.toMinutes(millis)));

परिणामस्वरूप एक सही प्रारूप:

18:44:19

प्रारूप प्राप्त करने का अन्य विकल्प hh:mm:ssसिर्फ:

   Date myDate = new Date(timeinMillis);
   SimpleDateFormat formatter = new SimpleDateFormat("HH:mm:ss");
   String myTime = formatter.format(myDate);
— Jorgesys
स्रोत
4

मैंने पहले उत्तर में दिखाए अनुसार कोशिश की। यह काम करता है, लेकिन माइनस ने मुझे भ्रम में ला दिया। ग्रूवी द्वारा मेरा जवाब:

import static java.util.concurrent.TimeUnit.*

...

private static String formatElapsedTime(long millis) {

    int hrs = MILLISECONDS.toHours(millis) % 24
    int min = MILLISECONDS.toMinutes(millis) % 60
    int sec = MILLISECONDS.toSeconds(millis) % 60
    int mls = millis % 1000

    sprintf( '%02d:%02d:%02d (%03d)', [hrs, min, sec, mls])
}
— लेओनोव
स्रोत
3

कोटलिन के लिए

val hours = String.format("%02d", TimeUnit.MILLISECONDS.toHours(milSecs))
val minutes = String.format("%02d",
                        TimeUnit.MILLISECONDS.toMinutes(milSecs) - TimeUnit.HOURS.toMinutes(TimeUnit.MILLISECONDS.toHours(milSecs)))
val seconds = String.format("%02d",
                        TimeUnit.MILLISECONDS.toSeconds(milSecs) - TimeUnit.MINUTES.toSeconds(TimeUnit.MILLISECONDS.toMinutes(milSecs)))

जहां, milSecsमिलीसेकंड है

— किशन सोलंकी
स्रोत
1

खैर, आप कुछ इस तरह की कोशिश कर सकते हैं:

public String getElapsedTimeHoursMinutesSecondsString() {       
     long elapsedTime = getElapsedTime();  
     String format = String.format("%%0%dd", 2);  
     elapsedTime = elapsedTime / 1000;  
     String seconds = String.format(format, elapsedTime % 60);  
     String minutes = String.format(format, (elapsedTime % 3600) / 60);  
     String hours = String.format(format, elapsedTime / 3600);  
     String time =  hours + ":" + minutes + ":" + seconds;  
     return time;  
 }

एक समय मान के लिए मिलीसेकंड परिवर्तित करने के लिए

— गुमनाम
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.