जावा में मिलीसेकंड को "एक्स मिनट, एक्स सेकंड" में कैसे बदलें?

Question

मैं उस समय का उपयोग करके रिकॉर्ड करना चाहता हूं System.currentTimeMillis()जब कोई उपयोगकर्ता मेरे कार्यक्रम में कुछ शुरू करता है। जब वह समाप्त हो जाता है, तो मैं चर System.currentTimeMillis()से वर्तमान को घटा दूंगा start, और मैं उन्हें एक मानव पठनीय प्रारूप जैसे "XX घंटे, XX मिनट, XX सेकंड" या यहां तक ​​कि "XX मिनट, XX सेकंड" का उपयोग करके बीता हुआ समय दिखाना चाहता हूं क्योंकि किसी को एक घंटा लेने की संभावना नहीं है।

ऐसा करने का सबसे अच्छा तरीका क्या है?

Comments

यदि वे एक घंटे से अधिक समय लेते हैं, तब भी आप कुछ ऐसा प्रिंट कर सकते हैं; 90 मिनट, 53 सेकंड।

— 19 Law में पीटर लॉरी

मेरा जवाब 6 साल देर से आता है, लेकिन मुझे लगता है कि यह स्वीकार किए गए लोगों की तुलना में अधिक सामान्य है: stackoverflow.com/a/35082080/82609

— सेबेस्टियन लम्बर

जावा में दिन, घंटे, मिनट, सेकंड में कनवर्ट

— sumit kumar pradhan

Answer 1

java.util.concurrent.TimeUnitकक्षा का उपयोग करें :

String.format("%d min, %d sec", 
    TimeUnit.MILLISECONDS.toMinutes(millis),
    TimeUnit.MILLISECONDS.toSeconds(millis) - 
    TimeUnit.MINUTES.toSeconds(TimeUnit.MILLISECONDS.toMinutes(millis))
);

नोट: TimeUnitजावा 1.5 विनिर्देशन का हिस्सा है, लेकिन toMinutesजावा 1.6 के रूप में जोड़ा गया था।

मूल्यों में 0-9 के लिए एक अग्रणी शून्य जोड़ने के लिए, बस करें:

String.format("%02d min, %02d sec", 
    TimeUnit.MILLISECONDS.toMinutes(millis),
    TimeUnit.MILLISECONDS.toSeconds(millis) - 
    TimeUnit.MINUTES.toSeconds(TimeUnit.MILLISECONDS.toMinutes(millis))
);

यदि TimeUnitया toMinutesअसमर्थित हैं (जैसे एपीआई संस्करण 9 से पहले एंड्रॉइड पर), तो निम्नलिखित समीकरणों का उपयोग करें:

int seconds = (int) (milliseconds / 1000) % 60 ;
int minutes = (int) ((milliseconds / (1000*60)) % 60);
int hours   = (int) ((milliseconds / (1000*60*60)) % 24);
//etc...

Comments

int months = (int) ((float) days / 30.4368499f); int years = (int) ((float) days / 365.242199f);

— नाथन श्वरमन

आईडी मिनटों को घटाने के बजाय मॉड 60 का उपयोग करने का सुझाव देती है, यह साफ दिखता है। हालांकि, किसी को यह जानने की जरूरत है कि 1 मिनट = 60 सेकंड ऐसा करने के लिए ... =)

— प्रति अलेक्जेंडरसन

@AndreasDietrich SimpleDateFormat समय के अंतर के लिए काम नहीं करता है क्योंकि यह केवल युग से वापसी की तारीख है!

— मुहम्मद बाबर

int hours = (int) ((milliseconds / (1000*60*60)) % 24)यह काम नहीं करता है! इसके बजाय यह इस तरह होना चाहिएint hours = (int) (milliseconds / (1000*60*60)) ;

— मुहम्मद बाबर

अगर कोई वीडियो फ़ाइलों के लिए प्रारूप चाहता है ( h: mm: ss ):String.format("%01d:%02d:%02d", hours, minutes, seconds);

— kazy

Answer 2

@ सिद्धदेव के उत्तर के आधार पर, मैंने एक फ़ंक्शन लिखा जो मिलीसेकंड को एक स्वरूपित स्ट्रिंग में परिवर्तित करता है:

   /**
     * Convert a millisecond duration to a string format
     * 
     * @param millis A duration to convert to a string form
     * @return A string of the form "X Days Y Hours Z Minutes A Seconds".
     */
    public static String getDurationBreakdown(long millis) {
        if(millis < 0) {
            throw new IllegalArgumentException("Duration must be greater than zero!");
        }

        long days = TimeUnit.MILLISECONDS.toDays(millis);
        millis -= TimeUnit.DAYS.toMillis(days);
        long hours = TimeUnit.MILLISECONDS.toHours(millis);
        millis -= TimeUnit.HOURS.toMillis(hours);
        long minutes = TimeUnit.MILLISECONDS.toMinutes(millis);
        millis -= TimeUnit.MINUTES.toMillis(minutes);
        long seconds = TimeUnit.MILLISECONDS.toSeconds(millis);

        StringBuilder sb = new StringBuilder(64);
        sb.append(days);
        sb.append(" Days ");
        sb.append(hours);
        sb.append(" Hours ");
        sb.append(minutes);
        sb.append(" Minutes ");
        sb.append(seconds);
        sb.append(" Seconds");

        return(sb.toString());
    }

Comments

इस तरह की स्थिति से बचने के लिए आपको सिंगल / मल्टीपल के लिए एक चेकिंग करनी चाहिए:1 Days 1 Hours 1 Minutes 1 Seconds

— डैनियल

हम घटाव के बजाय मापांक फ़ंक्शन का उपयोग कर सकते हैं: long days = TimeUnit.MILLISECONDS.toDays(millis); long hours = TimeUnit.MILLISECONDS.toHours(millis) % 24; long minutes = TimeUnit.MILLISECONDS.toMinutes(millis) % 60; long seconds = TimeUnit.MILLISECONDS.toSeconds(millis) % 60; long milliseconds = millis % 1000; और स्ट्रिंग.फॉर्मेट विधि:return String.format("%d Days %d Hours %d Minutes %d Seconds %d Milliseconds", days, hours, minutes, seconds, milliseconds);

— जोस टेपेडिनो

Answer 3

long time = 1536259;

return (new SimpleDateFormat("mm:ss:SSS")).format(new Date(time));

प्रिंटों:

25: 36: 259

Comments

मुझे सबसे अच्छा तरीका पसंद है अगर इसकी सादगी और कुछ नहीं है! चूंकि हम समय और अवधि के साथ काम कर रहे हैं इसलिए मैं आमतौर पर जोडा का उपयोग करता हूं। एक उदाहरण यदि आपके पास दो DateTimes हैं, तो क्रमशः शुरू करें और समाप्त करें:Duration dur = new Duration(start, end); long millis = dur.getMillis();

— TechTrip

मुझे जोडा फॉर्मेटर्स का उपयोग करने के 2 तरीके नोट करने चाहिए। अपने विषय पर पहली भिन्नता: DateTimeFormat.forPattern("mm:ss:SSS").print(new DateTime(time)); या अवधि को उस अवधि में रूपांतरित करें, जो स्वचालित रूप से एक Joda का उपयोग करके मुद्रित की जा सकती है PeriodFormatter। यदि आईएसओ कालक्रम के अलावा अन्य रूपांतरण में सटीकता का नुकसान हो सकता है। मान लीजिए कि चर द्वारा प्रतिनिधित्व अवधि duration। Period period = duration.toPeriod().normalizedStandard(PeriodType.time()); PeriodFormat.getDefault().print(period)) आउटपुट बहुत बढ़िया है: 1 दूसरा और 581 मिलीसेकंड, जो मुख्य प्रश्न का उत्तर दे रहा है।

— टेकट्रिप

यहाँ थोड़ी देर :) लेकिन क्या आपको यहां simpleDateFormat.setTimezone (TimeZone.getTimeZone ("GMT")) डालने की आवश्यकता नहीं होगी जब तक कि यह आपका वास्तविक समय नहीं है?

— ओलले सॉडरस्ट्रॉम

@ ओललेस्डरस्ट्रम वास्तव में टाइमज़ोन के साथ एक मुद्दा है। लेकिन इसे GMT या UTC में सेट करने से 1 घंटे से छोटे सभी अवधि के लिए घंटे का हिस्सा 0 के बजाय 12 हो जाता है।

— एपिसोड

टाइमज़ोन यहाँ एकमात्र मुद्दा नहीं है ... यह उत्तर भ्रामक है और जावा के नए नोटों को गंभीर रूप से भ्रमित कर सकता है। यहां तक ​​कि निरर्थक बाहरी कोष्ठकों की अनदेखी करते हुए, ओपी ने पूछा कि कैसे एक अवधि (दो समय के बीच का अंतर, एमएस में मापा जाता है) पेश किया जाए। उस अवधि को "समय" कहा जाता है और इसे 1 जनवरी, 1970 से एक ऑफसेट के रूप में माना जाता है, इसके छोटे घटकों को प्रारूपित करने के लिए सिर्फ गलत है ... गलत इमो। क्या अधिक है, बहुत ही दृष्टिकोण इस उत्तर के द्वारा 3 साल पहले ही सुझाया गया था (टाइमजोन समस्याओं पर अधिक विवरण के लिए टिप्पणियां देखें)।

— एमोस कारपेंटर

Answer 4

उह ... एक सेकंड में कितने मिलीसेकंड होते हैं? और एक मिनट में? विभाजन इतना कठिन नहीं है।

int seconds = (int) ((milliseconds / 1000) % 60);
int minutes = (int) ((milliseconds / 1000) / 60);

घंटे, दिन, सप्ताह, महीने, वर्ष, दशक, जो कुछ भी हो, उस तरह जारी रखें।

Comments

वास्तव में, एक घंटे से अधिक समय तक ऐसा करना एक अच्छा विचार नहीं है क्योंकि परिणाम गलत हो सकते हैं / अनजाने में दिन की बचत समय (23 या 24 घंटे के दिन) या लीप वर्ष शामिल होते हैं। अगर मैं "X 1 वर्ष / माह में होगा" पढ़ता हूं, तो मैं उम्मीद करता हूं कि यह वही तारीख और समय होगा।

— माइकल बोर्गवर्ड्ट

System.currentTimeMillis () डीएसटी के खिलाफ प्रतिरक्षा है इसलिए यह अतिरिक्त या लापता घंटों से भ्रमित नहीं होगा। यदि आपको दो विशिष्ट तिथियों के बीच अंतर दिखाने की आवश्यकता है, तो आप दिए गए समय के साथ दिनांक ऑब्जेक्ट का निर्माण बेहतर कर रहे हैं और उन दोनों के बीच अंतर दिखा सकते हैं।

— बोम्बे

हफ्तों से परे, यह अपरिभाषित है, क्योंकि महीने की लंबाई परिवर्तनशील है। तो वास्तव में, आपको दिए गए समय संदर्भ के सापेक्ष गणना करने की आवश्यकता है।

— फील्हो

Answer 5

जावा 8 में java.time पैकेज का उपयोग करना :

Instant start = Instant.now();
Thread.sleep(63553);
Instant end = Instant.now();
System.out.println(Duration.between(start, end));

आउटपुट आईएसओ 8601 अवधि प्रारूप में है : PT1M3.553S(1 मिनट और 3.553 सेकंड)।

Comments

यह भी देखें जावा में अवधि कैसे प्रारूपित करें? (उदाहरण स्वरूप H: MM: SS)

— वडज़िम

(ANDROID) को एपीआई स्तर 26 की आवश्यकता है

— किसी को

@SomeoneSomewhere Android के लिए एपीआई स्तर 26 के तहत बैकपोर्ट का उपयोग करें , देखें कि एंड्रॉइड प्रोजेक्ट में थ्रीटेनबप का उपयोग कैसे करें ।

— ओले वीवी

यह बहुत अच्छा है :) सिर के लिए धन्यवाद!

— किसी को कहीं

Answer 6

मैं इसके लिए अतिरिक्त निर्भरता में नहीं खींचूंगा (विभाजन इतना कठिन नहीं है, आखिरकार), लेकिन अगर आप वैसे भी कॉमन्स लैंग का उपयोग कर रहे हैं, तो DurationFormatUtils हैं ।

उदाहरण उपयोग ( यहाँ से अनुकूलित ):

import org.apache.commons.lang3.time.DurationFormatUtils

public String getAge(long value) {
    long currentTime = System.currentTimeMillis();
    long age = currentTime - value;
    String ageString = DurationFormatUtils.formatDuration(age, "d") + "d";
    if ("0d".equals(ageString)) {
        ageString = DurationFormatUtils.formatDuration(age, "H") + "h";
        if ("0h".equals(ageString)) {
            ageString = DurationFormatUtils.formatDuration(age, "m") + "m";
            if ("0m".equals(ageString)) {
                ageString = DurationFormatUtils.formatDuration(age, "s") + "s";
                if ("0s".equals(ageString)) {
                    ageString = age + "ms";
                }
            }
        }
    }
    return ageString;
}   

उदाहरण:

long lastTime = System.currentTimeMillis() - 2000;
System.out.println("Elapsed time: " + getAge(lastTime)); 

//Output: 2s

नोट : दो लोकल डिटाइम वस्तुओं का उपयोग करने के लिए आप मिल का उपयोग कर सकते हैं:

long age = ChronoUnit.MILLIS.between(initTime, LocalDateTime.now())

Comments

महान, मैं सिर्फ खुद से पूछ रहा था कि क्या एक मजबूत पुस्तकालय था जिसमें इस तरह की चीजें शामिल थीं।

— लाजिक

जैसा कि एक लिंक आम तौर पर बहुत उपयोगी नहीं है, मैंने एक उदाहरण जोड़ा कि इसका उपयोग कैसे किया जा सकता है।

— लेप

Answer 7

या तो हाथ विभाजन, या SimpleDateFormat एपीआई का उपयोग करें ।

long start = System.currentTimeMillis();
// do your work...
long elapsed = System.currentTimeMillis() - start;
DateFormat df = new SimpleDateFormat("HH 'hours', mm 'mins,' ss 'seconds'");
df.setTimeZone(TimeZone.getTimeZone("GMT+0"));
System.out.println(df.format(new Date(elapsed)));

बॉम्बे द्वारा संपादित करें : यह टिप्पणियों में दिखाया गया है कि यह दृष्टिकोण केवल छोटे अवधि (यानी एक दिन से भी कम) के लिए काम करता है।

Comments

वाह। यह एक बुराई है, टाइमजोन-निर्भर हैक। यह निर्दयता से टूट जाएगा जब आपके पास एक टाइमज़ोन ऑफसेट होता है जो 60 मिनट से अधिक नहीं होता है (और हमारे पास दुनिया में उन 30 मिनट के ऑफसेट टाइमज़ोन के कुछ जोड़े हैं)।

— बोम्बे

इसके अलावा, जैसे ही आप प्रारूप स्ट्रिंग में घंटों को शामिल करते हैं, वैसे ही खराब हो जाएंगे और समान कारणों से GMT + 0 पर नहीं हैं।

— बॉम्बे

हम कर? वास्तव में? कहाँ पे? आप पर शक नहीं, बस इसके बारे में पहले कभी नहीं सुना - विचार करने के लिए कुछ नया

— नुकसान;;

हाँ। विकिपीडिया पर "समय क्षेत्रों की सूची" की जाँच करें, उदाहरण के लिए नेपाल GMT + 05: 45 पर है।

— बॉम्बे

कैडरियन, अब यह केवल एक दिन से भी कम अवधि के लिए काम करेगा। घंटे की संख्या हमेशा 0 और 23 के बीच होगी, समावेशी।

— बोम्बे

Answer 8

यदि आप प्रारूपित करना चाहते हैं तो अधिक जानकारी जोड़ने के लिए जैसे: HH: mm: ss

0 <= एचएच <= अनंत

0 <= मिमी <60

0 <= ss <60

इसे इस्तेमाल करो:

int h = (int) ((startTimeInMillis / 1000) / 3600);
int m = (int) (((startTimeInMillis / 1000) / 60) % 60);
int s = (int) ((startTimeInMillis / 1000) % 60);

मैं अभी यह मुद्दा था और यह पता लगा

Comments

सबसे अच्छा जवाब यहाँ। हर कोई चीजों को इतना जटिल क्यों बनाना चाहता है? यह सरल गणित है, दोस्तों।

— लैम्बर्ट

Answer 9

मुझे लगता है कि सबसे अच्छा तरीका है:

String.format("%d min, %d sec", 
    TimeUnit.MILLISECONDS.toSeconds(length)/60,
    TimeUnit.MILLISECONDS.toSeconds(length) % 60 );

Comments

मिनटों के लिए आप TimeUnit.MILLISECONDS.toMinutes (लंबाई)

— EminenT

Answer 10

सबसे छोटा समाधान:

यहाँ शायद सबसे छोटा है जो समय क्षेत्र से संबंधित है।

System.out.printf("%tT", millis-TimeZone.getDefault().getRawOffset());

उदाहरण के लिए कौन सा आउटपुट:

00:18:32

स्पष्टीकरण:

%tTके रूप में 24 घंटे की घड़ी के लिए स्वरूपित समय है %tH:%tM:%tS।

%tTइनपुट के रूप में भी लॉन्ग स्वीकार करता है, इसलिए ए बनाने की आवश्यकता नहीं है Date। printf()केवल मिलीसेकंड में निर्दिष्ट समय को प्रिंट करेगा, लेकिन वर्तमान समय क्षेत्र में इसलिए हमें वर्तमान समय क्षेत्र की कच्ची ऑफसेट को घटाना होगा ताकि 0 मिलीसेकंड 0 घंटे का हो और वर्तमान समय क्षेत्र का समय ऑफसेट मान न हो।

नोट # 1: यदि आपको परिणाम की आवश्यकता है String, तो आप इसे इस तरह प्राप्त कर सकते हैं:

String t = String.format("%tT", millis-TimeZone.getDefault().getRawOffset());

नोट # 2: यह केवल सही परिणाम देता है यदि millisएक दिन से कम है क्योंकि दिन का हिस्सा आउटपुट में शामिल नहीं है।

Comments

यह इतनी बड़ी शॉर्ट कट है, लेकिन जब मैं इसका उपयोग करता हूं तो मुझे अपेक्षित परिणाम नहीं मिलते हैं। इसलिए मेरे पास है: long millis = 8398;और जब मैं पास होता हूं तो String.format("%tT", millis)मेरा आउटपुट 19:00:08 है। 19 कहाँ से आता है?

— Nelda.techspiress

@ Nelda.techspiress यह आपके टाइमज़ोन की भरपाई है। आपको इससे घटाना TimeZone.getDefault().getRawOffset()होगा, ठीक उसी तरह जैसे उत्तर में लिखा गया है:String.format("%tT", millis-TimeZone.getDefault().getRawOffset())

— icza

इसका ख्याल रखा। स्पष्ट करने के लिए आपको धन्यवाद।

— नेल्दा.टेकस्पैरेस

Answer 11

Joda समय

Joda-Time का उपयोग करना :

DateTime startTime = new DateTime();

// do something

DateTime endTime = new DateTime();
Duration duration = new Duration(startTime, endTime);
Period period = duration.toPeriod().normalizedStandard(PeriodType.time());
System.out.println(PeriodFormat.getDefault().print(period));

Comments

PeriodFormatअंतिम पंक्ति में उसके लिए कोई ज़रूरत नहीं है । बस डिफ़ॉल्ट रूप से ISO 8601 अवधि स्ट्रिंग Period::toStringप्राप्त करने के लिए कॉल करें ।

— बेसिल बोर्के

Answer 12

@ ब्रेंट-नैश योगदान पर दोबारा गौर करते हुए, हम घटाव के बजाय मापांक फ़ंक्शन का उपयोग कर सकते हैं और परिणाम स्ट्रिंग के लिए String.format विधि का उपयोग कर सकते हैं:

  /**
   * Convert a millisecond duration to a string format
   * 
   * @param millis A duration to convert to a string form
   * @return A string of the form "X Days Y Hours Z Minutes A Seconds B Milliseconds".
   */
   public static String getDurationBreakdown(long millis) {
       if (millis < 0) {
          throw new IllegalArgumentException("Duration must be greater than zero!");
       }

       long days = TimeUnit.MILLISECONDS.toDays(millis);
       long hours = TimeUnit.MILLISECONDS.toHours(millis) % 24;
       long minutes = TimeUnit.MILLISECONDS.toMinutes(millis) % 60;
       long seconds = TimeUnit.MILLISECONDS.toSeconds(millis) % 60;
       long milliseconds = millis % 1000;

       return String.format("%d Days %d Hours %d Minutes %d Seconds %d Milliseconds",
                            days, hours, minutes, seconds, milliseconds);
   }

Answer 13

एपीआई 9 के नीचे Android के लिए

(String.format("%d hr %d min, %d sec", millis/(1000*60*60), (millis%(1000*60*60))/(1000*60), ((millis%(1000*60*60))%(1000*60))/1000)) 

Answer 14

छोटे समय के लिए, एक घंटे से भी कम समय में, मैं पसंद करता हूं:

long millis = ...

System.out.printf("%1$TM:%1$TS", millis);
// or
String str = String.format("%1$TM:%1$TS", millis);

लंबे समय तक इंटरवेल के लिए:

private static final long HOUR = TimeUnit.HOURS.toMillis(1);
...
if (millis < HOUR) {
    System.out.printf("%1$TM:%1$TS%n", millis);
} else {
    System.out.printf("%d:%2$TM:%2$TS%n", millis / HOUR, millis % HOUR);
}

Comments

यह एक अनमोल संकेत है, Java Formatter API ( docs.oracle.com/javase/8/docs/api/java/util/Formatter.html ) के साथ दिनांक और समय के लिए ऐसी कई संभावनाएँ हैं ! आपके पास परिणाम के साथ और भी परिणाम हो सकते हैं: System.out.printf ("% 1 $ tH:% 1 $ tM:% 1 $ tS% n", मिली); या यहां तक ​​कि System.out.printf ("% 1 $ tT% n", मिली);

— जोस Tepedino

@JoseTepedino लेकिन आप जानते हैं कि %tH केवल 0 से 23 घंटे तक ही दिखता है ? इसका मतलब है कि उदाहरण के लिए 24 घंटे प्रदर्शित किए जाएंगे 00, 25 घंटे के रूप में 01... उसी के लिए मान्य %tTदिन चुपचाप छोड़ दिए जाएंगे। यकीन है, यह भी प्रदर्शित दिन हो सकता है, लेकिन जब मैं यह लिखा था कि समस्या के लिए एक overkill होगा (2011 में वापस) [:-)

— user85421

मैं देख रहा हूं ... जो वास्तव में केवल एक दिन (24 घंटों) से कम समय के लिए काम करेगा। धन्यवाद।

— जोस Tepedino

Answer 15

मेरी सरल गणना:

String millisecToTime(int millisec) {
    int sec = millisec/1000;
    int second = sec % 60;
    int minute = sec / 60;
    if (minute >= 60) {
        int hour = minute / 60;
        minute %= 60;
        return hour + ":" + (minute < 10 ? "0" + minute : minute) + ":" + (second < 10 ? "0" + second : second);
    }
    return minute + ":" + (second < 10 ? "0" + second : second);
}

मुबारक कोडिंग :)

Comments

मुझे लगता है कि इस फ़ंक्शन के लिए अधिक उपयुक्त है क्योंकि System.currentTimeMillis () एक लंबा मान लौटाता है।

— अप्रोदन

यह सही नहीं है, क्या आपने आउटपुट चेक किया है?

— जोर्जेस

Answer 16

यहाँ ब्रेंट नैश के उत्तर पर आधारित एक उत्तर है, आशा है कि मदद करता है!

public static String getDurationBreakdown(long millis)
{
    String[] units = {" Days ", " Hours ", " Minutes ", " Seconds "};
    Long[] values = new Long[units.length];
    if(millis < 0)
    {
        throw new IllegalArgumentException("Duration must be greater than zero!");
    }

    values[0] = TimeUnit.MILLISECONDS.toDays(millis);
    millis -= TimeUnit.DAYS.toMillis(values[0]);
    values[1] = TimeUnit.MILLISECONDS.toHours(millis);
    millis -= TimeUnit.HOURS.toMillis(values[1]);
    values[2] = TimeUnit.MILLISECONDS.toMinutes(millis);
    millis -= TimeUnit.MINUTES.toMillis(values[2]);
    values[3] = TimeUnit.MILLISECONDS.toSeconds(millis);

    StringBuilder sb = new StringBuilder(64);
    boolean startPrinting = false;
    for(int i = 0; i < units.length; i++){
        if( !startPrinting && values[i] != 0)
            startPrinting = true;
        if(startPrinting){
            sb.append(values[i]);
            sb.append(units[i]);
        }
    }

    return(sb.toString());
}

Answer 17

    long startTime = System.currentTimeMillis();
    // do your work...
    long endTime=System.currentTimeMillis();
    long diff=endTime-startTime;       
    long hours=TimeUnit.MILLISECONDS.toHours(diff);
    diff=diff-(hours*60*60*1000);
    long min=TimeUnit.MILLISECONDS.toMinutes(diff);
    diff=diff-(min*60*1000);
    long seconds=TimeUnit.MILLISECONDS.toSeconds(diff);
    //hour, min and seconds variables contains the time elapsed on your work

Comments

लाइन 6 पर सूत्र गलत है। diff=diff-(hours*60*1000);होना चाहिए diff=diff-(hours*60*60*1000);। मैंने इसे संपादित करने की कोशिश की, लेकिन StackOverflow की कष्टप्रद संपादन नीति कहती है कि यह संपादन के लिए पर्याप्त वर्ण नहीं है।

— quux00

Answer 18

सबसे पहले, System.currentTimeMillis()और Instant.now()समय के लिए आदर्श नहीं हैं। वे दोनों दीवार-घड़ी के समय की रिपोर्ट करते हैं, जिसे कंप्यूटर ठीक से नहीं जानता है, और जो गलत तरीके से आगे बढ़ सकता है, जिसमें पीछे की तरफ जाना भी शामिल है यदि उदाहरण के लिए एनटीपी डेमॉन सिस्टम समय को ठीक करता है। यदि आपकी टाइमिंग किसी एक मशीन पर होती है तो आपको इसके बजाय System.nanoTime () का उपयोग करना चाहिए ।

दूसरी बात, जावा 8 से java.time। अवधि एक अवधि का प्रतिनिधित्व करने का सबसे अच्छा तरीका है:

long start = System.nanoTime();
// do things...
long end = System.nanoTime();
Duration duration = Duration.ofNanos(end - start);
System.out.println(duration); // Prints "PT18M19.511627776S"
System.out.printf("%d Hours %d Minutes %d Seconds%n",
        duration.toHours(), duration.toMinutes() % 60, duration.getSeconds() % 60);
// prints "0 Hours 18 Minutes 19 Seconds"

Answer 19

यदि आप जानते हैं कि समय का अंतर एक घंटे से कम होगा, तो आप निम्नलिखित कोड का उपयोग कर सकते हैं:

    Calendar c1 = Calendar.getInstance();
    Calendar c2 = Calendar.getInstance();

    c2.add(Calendar.MINUTE, 51);

    long diff = c2.getTimeInMillis() - c1.getTimeInMillis();

    c2.set(Calendar.MINUTE, 0);
    c2.set(Calendar.HOUR, 0);
    c2.set(Calendar.SECOND, 0);

    DateFormat df = new SimpleDateFormat("mm:ss");
    long diff1 = c2.getTimeInMillis() + diff;
    System.out.println(df.format(new Date(diff1)));

यह परिणाम होगा: 51:00

Answer 20

यह उत्तर ऊपर दिए गए कुछ उत्तरों के समान है। हालांकि, मुझे लगता है कि यह फायदेमंद होगा क्योंकि, अन्य उत्तरों के विपरीत, यह किसी भी अतिरिक्त अल्पविराम या व्हाट्सएप को हटा देगा और संक्षिप्त नाम संभालता है।

/**
 * Converts milliseconds to "x days, x hours, x mins, x secs"
 * 
 * @param millis
 *            The milliseconds
 * @param longFormat
 *            {@code true} to use "seconds" and "minutes" instead of "secs" and "mins"
 * @return A string representing how long in days/hours/minutes/seconds millis is.
 */
public static String millisToString(long millis, boolean longFormat) {
    if (millis < 1000) {
        return String.format("0 %s", longFormat ? "seconds" : "secs");
    }
    String[] units = {
            "day", "hour", longFormat ? "minute" : "min", longFormat ? "second" : "sec"
    };
    long[] times = new long[4];
    times[0] = TimeUnit.DAYS.convert(millis, TimeUnit.MILLISECONDS);
    millis -= TimeUnit.MILLISECONDS.convert(times[0], TimeUnit.DAYS);
    times[1] = TimeUnit.HOURS.convert(millis, TimeUnit.MILLISECONDS);
    millis -= TimeUnit.MILLISECONDS.convert(times[1], TimeUnit.HOURS);
    times[2] = TimeUnit.MINUTES.convert(millis, TimeUnit.MILLISECONDS);
    millis -= TimeUnit.MILLISECONDS.convert(times[2], TimeUnit.MINUTES);
    times[3] = TimeUnit.SECONDS.convert(millis, TimeUnit.MILLISECONDS);
    StringBuilder s = new StringBuilder();
    for (int i = 0; i < 4; i++) {
        if (times[i] > 0) {
            s.append(String.format("%d %s%s, ", times[i], units[i], times[i] == 1 ? "" : "s"));
        }
    }
    return s.toString().substring(0, s.length() - 2);
}

/**
 * Converts milliseconds to "x days, x hours, x mins, x secs"
 * 
 * @param millis
 *            The milliseconds
 * @return A string representing how long in days/hours/mins/secs millis is.
 */
public static String millisToString(long millis) {
    return millisToString(millis, false);
}

Answer 21

वहाँ एक समस्या है। जब मिलीसेकंड 59999 है, तो वास्तव में यह 1 मिनट है, लेकिन इसकी गणना 59 सेकंड के रूप में की जाएगी और 999 मिलीसेकंड खो जाएगा।

यहां पिछले उत्तरों पर आधारित एक संशोधित संस्करण है, जो इस नुकसान को हल कर सकता है:

public static String formatTime(long millis) {
    long seconds = Math.round((double) millis / 1000);
    long hours = TimeUnit.SECONDS.toHours(seconds);
    if (hours > 0)
        seconds -= TimeUnit.HOURS.toSeconds(hours);
    long minutes = seconds > 0 ? TimeUnit.SECONDS.toMinutes(seconds) : 0;
    if (minutes > 0)
        seconds -= TimeUnit.MINUTES.toSeconds(minutes);
    return hours > 0 ? String.format("%02d:%02d:%02d", hours, minutes, seconds) : String.format("%02d:%02d", minutes, seconds);
}

Answer 22

यह जावा 9 में आसान है:

    Duration elapsedTime = Duration.ofMillis(millisDiff );
    String humanReadableElapsedTime = String.format(
            "%d hours, %d mins, %d seconds",
            elapsedTime.toHours(),
            elapsedTime.toMinutesPart(),
            elapsedTime.toSecondsPart());

यह जैसे एक स्ट्रिंग पैदा करता है 0 hours, 39 mins, 9 seconds ।

यदि आप स्वरूपण से पहले पूरे सेकंड में चक्कर लगाना चाहते हैं:

    elapsedTime = elapsedTime.plusMillis(500).truncatedTo(ChronoUnit.SECONDS);

यदि वे 0 हैं तो घंटों को छोड़ने के लिए:

    long hours = elapsedTime.toHours();
    String humanReadableElapsedTime;
    if (hours == 0) {
        humanReadableElapsedTime = String.format(
                "%d mins, %d seconds",
                elapsedTime.toMinutesPart(),
                elapsedTime.toSecondsPart());

    } else {
        humanReadableElapsedTime = String.format(
                "%d hours, %d mins, %d seconds",
                hours,
                elapsedTime.toMinutesPart(),
                elapsedTime.toSecondsPart());
    }

अब हम उदाहरण के लिए हो सकते हैं 39 mins, 9 seconds।

अग्रणी शून्य के साथ मिनट और सेकंड प्रिंट करने के लिए, उन्हें हमेशा दो अंक बनाने के लिए, बस 02संबंधित प्रारूप निर्दिष्टकों में डालें : इस प्रकार:

    String humanReadableElapsedTime = String.format(
            "%d hours, %02d mins, %02d seconds",
            elapsedTime.toHours(),
            elapsedTime.toMinutesPart(),
            elapsedTime.toSecondsPart());

अब हम उदाहरण के लिए हो सकते हैं 0 hours, 39 mins, 09 seconds।

Comments

पूर्ववर्ती संख्या 0 होने पर घंटे / मिनट / सेकंड निकालने का कोई प्रारूपण? मेरा मतलब है कि अगर यह स्थिति के साथ प्राप्त करने योग्य है, लेकिन इस तरह के स्ट्रिंग स्वरूपण या कुछ के अस्तित्व के बारे में क्या कोई है?

— फरीद

नहीं, क्षमा करें, @FARID, आपको चाहिए if- elseवहां।

— ओले वीवी

Answer 23

सही तार के लिए ("1 घंटे, 3 सेकेंड", "3 मिनट" लेकिन "0 घंटे, 0 मिनट, 3 सेकंड") मैं इस कोड को नहीं लिखूंगा:

int seconds = (int)(millis / 1000) % 60 ;
int minutes = (int)((millis / (1000*60)) % 60);
int hours = (int)((millis / (1000*60*60)) % 24);
int days = (int)((millis / (1000*60*60*24)) % 365);
int years = (int)(millis / 1000*60*60*24*365);

ArrayList<String> timeArray = new ArrayList<String>();

if(years > 0)   
    timeArray.add(String.valueOf(years)   + "y");

if(days > 0)    
    timeArray.add(String.valueOf(days) + "d");

if(hours>0)   
    timeArray.add(String.valueOf(hours) + "h");

if(minutes>0) 
    timeArray.add(String.valueOf(minutes) + "min");

if(seconds>0) 
    timeArray.add(String.valueOf(seconds) + "sec");

String time = "";
for (int i = 0; i < timeArray.size(); i++) 
{
    time = time + timeArray.get(i);
    if (i != timeArray.size() - 1)
        time = time + ", ";
}

if (time == "")
  time = "0 sec";

Answer 24

मैंने @MyKuLLSKI के उत्तर को संशोधित किया और प्लूरलाइज़ेशन समर्थन जोड़ा। मैंने सेकंड निकाल लिए क्योंकि मुझे उनकी ज़रूरत नहीं थी, हालांकि अगर आपको ज़रूरत है तो इसे फिर से जोड़ने के लिए स्वतंत्र महसूस करें।

public static String intervalToHumanReadableTime(int intervalMins) {

    if(intervalMins <= 0) {
        return "0";
    } else {

        long intervalMs = intervalMins * 60 * 1000;

        long days = TimeUnit.MILLISECONDS.toDays(intervalMs);
        intervalMs -= TimeUnit.DAYS.toMillis(days);
        long hours = TimeUnit.MILLISECONDS.toHours(intervalMs);
        intervalMs -= TimeUnit.HOURS.toMillis(hours);
        long minutes = TimeUnit.MILLISECONDS.toMinutes(intervalMs);

        StringBuilder sb = new StringBuilder(12);

        if (days >= 1) {
            sb.append(days).append(" day").append(pluralize(days)).append(", ");
        }

        if (hours >= 1) {
            sb.append(hours).append(" hour").append(pluralize(hours)).append(", ");
        }

        if (minutes >= 1) {
            sb.append(minutes).append(" minute").append(pluralize(minutes));
        } else {
            sb.delete(sb.length()-2, sb.length()-1);
        }

        return(sb.toString());          

    }

}

public static String pluralize(long val) {
    return (Math.round(val) > 1 ? "s" : "");
}

Comments

int intervalMins बनाम long millis

— किकेनेट

Answer 25

मैंने इसे दूसरे उत्तर में कवर किया है लेकिन आप कर सकते हैं:

public static Map<TimeUnit,Long> computeDiff(Date date1, Date date2) {
    long diffInMillies = date2.getTime() - date1.getTime();
    List<TimeUnit> units = new ArrayList<TimeUnit>(EnumSet.allOf(TimeUnit.class));
    Collections.reverse(units);
    Map<TimeUnit,Long> result = new LinkedHashMap<TimeUnit,Long>();
    long milliesRest = diffInMillies;
    for ( TimeUnit unit : units ) {
        long diff = unit.convert(milliesRest,TimeUnit.MILLISECONDS);
        long diffInMilliesForUnit = unit.toMillis(diff);
        milliesRest = milliesRest - diffInMilliesForUnit;
        result.put(unit,diff);
    }
    return result;
}

आउटपुट कुछ इस तरह है Map:{DAYS=1, HOURS=3, MINUTES=46, SECONDS=40, MILLISECONDS=0, MICROSECONDS=0, NANOSECONDS=0} , जिसमें यूनिट ऑर्डर किए गए हैं।

यह आप पर है कि लक्ष्य के लोकेल के अनुसार इस डेटा का अंतर्राष्ट्रीयकरण कैसे किया जाए।

Answer 26

Java.util.concurrent.TimeUnit का उपयोग करें, और इस सरल विधि का उपयोग करें:

private static long timeDiff(Date date, Date date2, TimeUnit unit) {
    long milliDiff=date2.getTime()-date.getTime();
    long unitDiff = unit.convert(milliDiff, TimeUnit.MILLISECONDS);
    return unitDiff; 
}

उदाहरण के लिए:

SimpleDateFormat sdf = new SimpleDateFormat("yy/MM/dd HH:mm:ss");  
Date firstDate = sdf.parse("06/24/2017 04:30:00");
Date secondDate = sdf.parse("07/24/2017 05:00:15");
Date thirdDate = sdf.parse("06/24/2017 06:00:15");

System.out.println("days difference: "+timeDiff(firstDate,secondDate,TimeUnit.DAYS));
System.out.println("hours difference: "+timeDiff(firstDate,thirdDate,TimeUnit.HOURS));
System.out.println("minutes difference: "+timeDiff(firstDate,thirdDate,TimeUnit.MINUTES));
System.out.println("seconds difference: "+timeDiff(firstDate,thirdDate,TimeUnit.SECONDS));

Answer 27

DurationFormatUtils.formatDurationHMS (लंबी)