दो जावा तिथि उदाहरणों के बीच अंतर की गणना

433

मैं java.util.Dateस्काला में जावा की कक्षा का उपयोग कर रहा हूं और एक Dateवस्तु और वर्तमान समय की तुलना करना चाहता हूं । मुझे पता है कि मैं गेटटाइम () का उपयोग करके डेल्टा की गणना कर सकता हूं:

(new java.util.Date()).getTime() - oldDate.getTime()

हालांकि, यह सिर्फ मुझे एक longप्रतिनिधित्व वाले मिलीसेकंड के साथ छोड़ देता है । क्या कोई समय पाने के लिए कोई सरल, अच्छा तरीका है?

java  date  time  timedelta  java.util.date 
— pr1001
स्रोत
10
क्यों नहीं समय के लिए प्यार? यदि आप जावा में तारीखों से निपटने जा रहे हैं तो यह बहुत अच्छा विकल्प है।
— डॉक्टर जोन्स
7
कृपया मेरे सुरुचिपूर्ण 2 लाइनर समाधान की जाँच करें, बिना जोडा का उपयोग किए बिना और परिणाम किसी भी टाइम यूनीट में दिए गए stackoverflow.com/a/10650881/82609 पर
— सेबस्टियन
2
उन सभी पर शर्म करो जो जोदा के समय की सिफारिश करते हैं, और एक सच्चे जावा उत्तर की सिफारिश नहीं करते हैं ...
— Zizouz212
2
@ Zizouz212 Joda-Time की सिफारिश करने के संबंध में, जावा के साथ बंडल किए गए पुराने डेट-टाइम क्लासेस खराब, वास्तविक खराब, खराब-डिज़ाइन किए गए, भ्रमित करने वाले और परेशानी वाले हैं। इतना बुरा कि जोडा-टाइम उनके प्रतिस्थापन के रूप में बेहद सफल हो गया। इतना बुरा कि यहां तक ​​कि सन / ओरेकल ने भी उन्हें छोड़ दिया, और जावा 8 और बाद के हिस्से के रूप में जावा.टाइम पैकेज को अपनाया। Java.time कक्षाएं जोडा-टाइम से प्रेरित हैं। Joda-Time और java.time दोनों का नेतृत्व एक ही आदमी, स्टीफन कॉलबोर्न करते हैं । मैं कहते थे, "किसी पर शर्म की बात है के उपयोग की सिफारिश Date, Calendarऔर SimpleDateFormat"।
— तुलसी बॉर्क
2
हालांकि सवाल पूछने के दौरान जोडा टाइम शायद एक अच्छा जवाब था, आज जावा 8 का उपयोग करने वाले किसी भी व्यक्ति के लिए सबसे अच्छा जवाब उपयोग java.time.Periodऔर / या है Duration। नीचे देखें बेसिल बॉर्क का जवाब ।
— ओले वीवी

जवाबों:

198

JDK Dateएपीआई दुर्भाग्य से बुरी तरह से टूट गया है। मैं जोडा टाइम लाइब्रेरी का उपयोग करने की सलाह देता हूं ।

Joda समय समय की एक अवधारणा है अंतराल :

Interval interval = new Interval(oldTime, new Instant());

संपादित करें: वैसे, Joda की दो अवधारणाएँ हैं: Intervalदो समय के इंस्टेंट के बीच समय के अंतराल का प्रतिनिधित्व करने के लिए (8am और 10am के बीच का समय का प्रतिनिधित्व करें), और aDuration यह वास्तविक समय सीमाओं के बिना समय की लंबाई का प्रतिनिधित्व करता है (जैसे दो घंटे का प्रतिनिधित्व करता है!)

यदि आप केवल समय की तुलना के बारे में परवाह करते हैं, तो अधिकांश Dateकार्यान्वयन (जेडीके एक सहित) Comparableइंटरफ़ेस लागू करते हैं जो आपको उपयोग करने की अनुमति देता हैComparable.compareTo()

— notnoop
स्रोत
btw - तुम्हारा मतलब है Comparable.compareTo(), नहीं Comparable.compare()।
— स्कॉट मॉरिसन
Joda-Time में विभिन्न तरीकों से समय की अवधि को चित्रित करने के लिए तीन कक्षाएं हैं: अंतराल, अवधि और अवधि। यह सही उत्तर इस पहले दो पर चर्चा करता है। अवधि के बारे में जानकारी के लिए मेरा जवाब देखें ।
— बेसिल बोर्क
जावा 8 में एक नई तारीख और टाइम एप है जैसे जोडा।
— 23
11
java.timeजावा 8 में नया पैकेज जोडा-टाइम से प्रेरित है, लेकिन ड्रॉप-इन रिप्लेसमेंट नहीं है। प्रत्येक के पास अपने पेशेवरों और विपक्ष हैं। सौभाग्य से आपको उनके बीच चयन नहीं करना है। जब तक आप अपने importवक्तव्यों से सावधान रहते हैं, तब तक अपनी ताकत के लिए प्रत्येक का उपयोग करें । Java.time के उदाहरण के लिए यह अन्य उत्तर देखें ।
— बेसिल बोर्क
6
FYI करें, जोडा-टाइम परियोजना अब रखरखाव मोड में है , जिसमें टीम java.time कक्षाओं में प्रवास की सलाह दे रही है । ओरेकल द्वारा ट्यूटोरियल देखें ।
— तुलसी बॉर्क
550

साधारण अंतर (बिना परिवाद के)

/**
 * Get a diff between two dates
 * @param date1 the oldest date
 * @param date2 the newest date
 * @param timeUnit the unit in which you want the diff
 * @return the diff value, in the provided unit
 */
public static long getDateDiff(Date date1, Date date2, TimeUnit timeUnit) {
    long diffInMillies = date2.getTime() - date1.getTime();
    return timeUnit.convert(diffInMillies,TimeUnit.MILLISECONDS);
}

और फिर आप कॉल कर सकते हैं:

getDateDiff(date1,date2,TimeUnit.MINUTES);

मिनट यूनिट में 2 तारीखों का अंतर पाने के लिए।

TimeUnitहै java.util.concurrent.TimeUnit, एक मानक जावा enum nanos से दिनों के लिए जा रहा।

मानव पठनीय अंतर (बिना परिवाद के)

public static Map<TimeUnit,Long> computeDiff(Date date1, Date date2) {

    long diffInMillies = date2.getTime() - date1.getTime();

    //create the list
    List<TimeUnit> units = new ArrayList<TimeUnit>(EnumSet.allOf(TimeUnit.class));
    Collections.reverse(units);

    //create the result map of TimeUnit and difference
    Map<TimeUnit,Long> result = new LinkedHashMap<TimeUnit,Long>();
    long milliesRest = diffInMillies;

    for ( TimeUnit unit : units ) {

        //calculate difference in millisecond 
        long diff = unit.convert(milliesRest,TimeUnit.MILLISECONDS);
        long diffInMilliesForUnit = unit.toMillis(diff);
        milliesRest = milliesRest - diffInMilliesForUnit;

        //put the result in the map
        result.put(unit,diff);
    }

    return result;
}

http://ideone.com/5dXeu6

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

आपको बस उस मैप को यूजर फ्रेंडली स्ट्रिंग में बदलना होगा।

चेतावनी

उपरोक्त कोड स्निपेट 2 उदाहरणों के बीच एक सरल अंतर की गणना करता है। यह एक डेलाइट सेविंग स्विच के दौरान समस्याएं पैदा कर सकता है, जैसे कि इस पोस्ट में बताया गया है । इसका मतलब यह है कि यदि आप बिना किसी समय के साथ तारीखों के बीच के अंतर की गणना करते हैं, तो आपके पास एक लापता दिन / घंटा हो सकता है।

मेरी राय में तारीख अलग तरह की व्यक्तिपरक है, खासकर दिनों में। आप कर सकते हैं:

  • 24h बीते समय की संख्या गिनें: दिन + 1 - दिन = 1 दिन = 24 ह

  • बीते हुए समय की संख्या को गिनें, दिन के उजाले की बचत का ध्यान रखें: दिन + 1 - दिन = 1 = 24 घंटे (लेकिन आधी रात के समय और दिन की बचत का उपयोग करके यह 0 दिन और 23 घंटे हो सकता है)

  • संख्या की गणना करें day switches, जिसका अर्थ है दिन + 1 1pm - दिन 11am = 1 दिन, भले ही बीता हुआ समय सिर्फ 2h है (या 1h यदि दिन की रोशनी की बचत है: p)

मेरा उत्तर मान्य है यदि आपकी तारीख की परिभाषा 1 मामले से मेल खाती है

JodaTime के साथ

यदि आप JodaTime का उपयोग कर रहे हैं, तो आप 2 इंस्टेंट (मिलि समर्थित ReadstInstant) तारीखों के साथ अंतर पा सकते हैं:

Interval interval = new Interval(oldInstant, new Instant());

लेकिन आप स्थानीय तिथियों / समय के लिए भी अंतर पा सकते हैं:

// returns 4 because of the leap year of 366 days
new Period(LocalDate.now(), LocalDate.now().plusDays(365*5), PeriodType.years()).getYears() 

// this time it returns 5
new Period(LocalDate.now(), LocalDate.now().plusDays(365*5+1), PeriodType.years()).getYears() 

// And you can also use these static methods
Years.yearsBetween(LocalDate.now(), LocalDate.now().plusDays(365*5)).getYears()
— सेबस्टियन लॉर्बर
स्रोत
वाह, आप वास्तव में एक पुराने कुत्ते को नई चाल सिखा सकते हैं! इसके बारे में पहले कभी नहीं सुना, तारीख के अंतर को सार्थक तार में अनुवाद करने के लिए बहुत उपयोगी है।
— जेरेमी गुडेल
@SebastienLorber टाइमटाइम में इस तरह से अंतर की गणना करने का एक तरीका है? "अलार्म अब से 3 दिन, 4 घंटे और 12 मिनट के लिए सेट है"।
— १५:१४ की तरह १२:१४
शानदार सामान ने वास्तव में मेरा बहुत समय बचाया। आपकी सहायता की सराहना।
— लुआजू आई एडविंसन
मैंने अपने जीवन के 3 दिनों को जावा डेट्स से निपटने में बर्बाद कर दिया और मैंने इसे बहुत दूर फेंक दिया और इसे बदल दिया। धन्यवाद।
— user1091524
यह सबसे अच्छा उत्तर है जो मैंने तब से देखा है जब से मैं स्टैकओवरफ़्लो पर आया था! : डी: डी: डी
— कोल्ड
153 
int diffInDays = (int)( (newerDate.getTime() - olderDate.getTime()) 
                 / (1000 * 60 * 60 * 24) )

ध्यान दें कि यह UTC तिथियों के साथ काम करता है, इसलिए यदि आप स्थानीय तिथियों को देखते हैं तो अंतर एक दिन का हो सकता है। और स्थानीय तिथियों के साथ इसे सही ढंग से काम करने के लिए दिन के समय की बचत के कारण पूरी तरह से अलग दृष्टिकोण की आवश्यकता होती है।

— माइकल बोर्गवर्ड
स्रोत
6
यह वास्तव में एंड्रॉइड में सही तरीके से काम नहीं करता है। राउंडिंग त्रुटियाँ मौजूद हैं। उदाहरण 19 से 21 मई को 1 दिन कहते हैं क्योंकि यह 1.99 से 1. कास्ट करता है। इंट से कास्टिंग करने से पहले राउंड का उपयोग करें।
— प्रतिज्ञा मंड्रेकर
4
यह सबसे अच्छा और सरल उत्तर है। दो तिथियों के बीच अंतर की गणना करते समय, स्थानीय समय क्षेत्र एक-दूसरे को घटाते हैं ... ताकि सही उत्तर (एक डबल के रूप में) बस ((डबल) (new.getTime) () - old.getTime ()) / द्वारा दिया जाए (86400.0 * 1000.0); ... एक दोहरे के रूप में, आपके पास भिन्नात्मक दिन होता है जिसे आसानी से HH: MM: ss में परिवर्तित किया जा सकता है।
— scottb
8
@ कॉट्सब: स्थानीय तारीखों के साथ समस्या यह है कि आपके पास दिन के उजाले की बचत का समय हो सकता है, जिसका अर्थ है कि कुछ दिनों में 23 या 25 घंटे हैं, संभावित रूप से परिणाम गड़बड़ कर सकते हैं।
— माइकल बोर्गवर्ड
1
@ समय: यह मेरे लिए 28 है जब उन्हें इस नई तारीख (115, 2, 26) की तरह परिभाषित करना; (params के लिए एपीआई डॉक्टर पर ध्यान दें)। क्या यह संभव है कि आप उन्हें यूएस की तारीख के प्रारूप का उपयोग कर रहे हैं और उदार मोड में हैं, ताकि 26/03/2015 को 2015 के 26 वें महीने के 3 वें दिन के रूप में व्याख्या की जाए?
— माइकल बॉर्गवर्ड
1
@ साइट: hm, मुझे यकीन नहीं है कि मुझे पहले एक अलग परिणाम क्यों मिला, लेकिन अब मैं आपकी त्रुटि को पुन: पेश कर सकता हूं। आपके कोड में ब्रेसिज़ मेरे उत्तर की तुलना में भिन्न हैं, जो अंतिम परिणाम के बजाय (endDate.getTime() - startDate.getTime())कास्ट होने का कारण बनता है int, और आपको पूर्णांक बहिर्वाह मिल रहा है।
— माइकल बोर्गवर्ड
54

जावा 8+ में निर्मित जावा.टाइम फ्रेमवर्क का उपयोग करना :

ZonedDateTime now = ZonedDateTime.now();
ZonedDateTime oldDate = now.minusDays(1).minusMinutes(10);
Duration duration = Duration.between(oldDate, now);
System.out.println("ISO-8601: " + duration);
System.out.println("Minutes: " + duration.toMinutes());

आउटपुट:

ISO-8601: PT24H10M

मिनट: 1450

अधिक जानकारी के लिए, Oracle ट्यूटोरियल और ISO 8601 मानक देखें।

— विटाली फेडोरेंको
स्रोत
5
यह, या दिनांक के Periodबजाय उपयोग करें Duration।
— एपेक्स
53

आपको अपनी समस्या को अधिक स्पष्ट रूप से परिभाषित करने की आवश्यकता है। आप केवल दो वस्तुओं के बीच मिलीसेकंड की संख्या ले सकतेDate हैं और 24 घंटे में मिलीसेकंड की संख्या से विभाजित कर सकते हैं, उदाहरण के लिए ... लेकिन:

  • यह समय क्षेत्र को ध्यान में नहीं रखेगा - Dateहमेशा यूटीसी में होता है
  • यह डेलाइट सेविंग टाइम को ध्यान में नहीं रखेगा (जहां ऐसे दिन हो सकते हैं जो केवल 23 घंटे लंबे होते हैं, उदाहरण के लिए)
  • यूटीसी के भीतर भी, 16 अगस्त को 11:00 बजे से 18 अगस्त के कितने दिन हैं? यह केवल 27 घंटे है, तो क्या इसका मतलब एक दिन है? या यह तीन दिन होना चाहिए क्योंकि इसमें तीन तिथियां शामिल हैं?
— जॉन स्कीट
स्रोत
1
मैंने सोचा java.util। दिनांक स्थानीय-डिफ़ॉल्ट (डिफ़ॉल्ट) टाइमज़ोन में व्याख्या किए गए समय-मिलिस प्रतिनिधित्व के आसपास सिर्फ एक छोटा आवरण था। किसी तिथि को प्रिंट करने से मुझे स्थानीय समय-क्षेत्र का प्रतिनिधित्व मिलता है। क्या मैं यहाँ भ्रमित हूँ?
— एड्रियन कोस्टर
46

tl; डॉ

अपने अप्रचलित कन्वर्ट java.util.Date, उनकी प्रतिस्थापन के लिए वस्तुओं java.time.Instant। फिर बीते हुए समय की गणना करें Duration।

Duration d = 
    Duration.between(                   // Calculate the span of time between two moments as a number of hours, minutes, and seconds.
        myJavaUtilDate.toInstant() ,    // Convert legacy class to modern class by calling new method added to the old class.
        Instant.now()                   // Capture the current moment in UTC. About two and a half hours later in this example.
    )
;

d.toString (): PT2H34M56S

d.toMinutes (): 154

d.toMinutesPart (): 34

आईएसओ 8601 प्रारूप: PnYnMnDTnHnMnS

समझदार मानक आईएसओ 8601 कई वर्षों, महीनों, दिनों, घंटों आदि के रूप में समय की अवधि के संक्षिप्त पाठ को परिभाषित करता है। मानक ऐसे काल को अवधि कहते हैं । प्रारूप "पीरियड" PnYnMnDTnHnMnSका Pअर्थ है, जहांT दिनांक भाग को समय भाग से अलग करता है, और बीच में संख्याओं के बाद एक अक्षर होता है।

उदाहरण:

  • P3Y6M4DT12H30M5S
    तीन साल, छह महीने, चार दिन, बारह घंटे, तीस मिनट और पांच सेकंड
  • PT4H30M
    साढ़े चार घंटे

java.time

Java.time जावा 8 में बनाया गया और बाद में ढांचा परेशानी वर्ष supplants java.util.Date/ java.util.Calendarवर्गों। नई कक्षाएं अत्यधिक सफल जोडा-टाइम फ्रेमवर्क से प्रेरित हैं , जिसका उद्देश्य इसके उत्तराधिकारी के रूप में है, जो अवधारणा में समान है लेकिन फिर से वास्तुकला में है। JSR 310 द्वारा परिभाषित । थ्रीटेन-एक्स्ट्रा प्रोजेक्ट द्वारा विस्तारित । ट्यूटोरियल देखें ।

पल

Instantकक्षा में समय रेखा पर एक पल का प्रतिनिधित्व करता यूटीसी के एक संकल्प के साथ नैनोसेकंड (नौ (9) एक दशमलव भिन्न के अंकों के लिए)।

Instant instant = Instant.now() ;  // Capture current moment in UTC.

विरासत से बचने के लिए सर्वश्रेष्ठ जैसे कि Date/ Calendar। लेकिन अगर आपको java.time में अपडेट नहीं किए गए पुराने कोड के साथ इंटर-ऑपरेट करना है , तो आगे और पीछे कन्वर्ट करें। पुरानी कक्षाओं में जोड़े गए नए रूपांतरण विधियों को कॉल करें। A से जाने के java.util.Dateलिए Instant, कॉल करें Date::toInstant।

Instant instant = myJavaUtilDate.toInstant() ;  // Convert from legacy `java.util.Date` class to modern `java.time.Instant` class.

समय की सीमा

Java.time कक्षाओं ने समय की अवधि को कई वर्षों, महीनों, दिनों, घंटों, मिनटों, सेकंडों के रूप में दो हिस्सों में विभाजित करने के इस विचार को विभाजित किया है:

  • Period सालों, महीनों, दिनों के लिए
  • Duration दिन, घंटे, मिनट, सेकंड के लिए

यहाँ एक उदाहरण है।

ZoneId zoneId = ZoneId.of ( "America/Montreal" );
ZonedDateTime now = ZonedDateTime.now ( zoneId );
ZonedDateTime future = now.plusMinutes ( 63 );
Duration duration = Duration.between ( now , future );

सांत्वना देना।

दोनों Periodऔर उनके मूल्य का एक स्ट्रिंग प्रतिनिधित्व उत्पन्न Durationकरने के लिए आईएसओ 8601 मानक का उपयोग करते हैं।

System.out.println ( "now: " + now + " to future: " + now + " = " + duration );

अब: 2015-11-26T00: 46: 48.016-05: 00 [अमेरिका / मॉन्ट्रियल] भविष्य के लिए: 2015-11-26T00: 46: 48.016-05: 00 [अमेरिका / मॉन्ट्रियल] = PT1H3M

जावा 9 Durationदिनों के हिस्से, घंटे का हिस्सा, मिनट का हिस्सा और सेकंड का हिस्सा पाने के लिए तरीके जोड़ता है ।

आप संपूर्ण अवधि में कुल दिन या घंटे या मिनट या सेकंड या मिलीसेकंड या नैनोसेकंड प्राप्त कर सकते हैं।

long totalHours = duration.toHours();

जावा 9 में Durationकक्षा को दिन, घंटे, मिनट, सेकंड, मिलीसेकंड / नैनोसेकंड के विभिन्न हिस्सों को वापस करने के लिए नए तरीके मिलते हैं । कॉल to…Partतरीके: toDaysPart(), toHoursPart(), और पर इतना।

ChronoUnit

यदि आप केवल समय की एक बड़ी ग्रैन्युलैरिटी की परवाह करते हैं, जैसे कि "बीते हुए दिनों की संख्या", तो ChronoUnitएनम का उपयोग करें ।

long daysElapsed = ChronoUnit.DAYS.between( earlier , later );

एक और उदाहरण।

Instant now = Instant.now();
Instant later = now.plus( Duration.ofHours( 2 ) );
…
long minutesElapsed = ChronoUnit.MINUTES.between( now , later );

120

जावा के बारे में

Java.time ढांचे जावा 8 और बाद में बनाया गया है। इन कक्षाओं परेशानी वर्ष प्रतिस्थापित विरासत जैसे तिथि-समय कक्षाएं java.util.Date, Calendar, और SimpleDateFormat।

Joda समय परियोजना, अब में रखरखाव मोड , प्रवास java.time को सलाह देता है।

अधिक जानने के लिए, Oracle ट्यूटोरियल देखें । और कई उदाहरणों और स्पष्टीकरणों के लिए ढेर अतिप्रवाह खोजें। विशिष्टता JSR 310 है ।

Java.time कक्षाएं कहाँ से प्राप्त करें?

द थ्रीटेन-एक्सट्रा परियोजना अतिरिक्त कक्षाओं के साथ java.time फैली हुई है। यह परियोजना java.time के लिए भविष्य के संभावित अतिरिक्त के लिए एक साबित जमीन है। आप यहाँ कुछ उपयोगी वर्गों जैसे मिल सकता है Interval, YearWeek, YearQuarter, और अधिक ।

Joda समय

अद्यतन: जोडा-टाइम परियोजना अब रखरखाव मोड में है , जिसमें टीम जावा को माइग्रेशन की सलाह दे रही है कक्षाओं में । मैं इस खंड को इतिहास के लिए अक्षुण्ण रखता हूं।

जोडा-टाइम लाइब्रेरी अपनी चूक के लिए आईएसओ 8601 का उपयोग करता है। इसका Periodवर्ग पार्स करता है और इन PnYnMnDTnHnMnS तार उत्पन्न करता है।

DateTime now = DateTime.now(); // Caveat: Ignoring the important issue of time zones.
Period period = new Period( now, now.plusHours( 4 ).plusMinutes( 30));
System.out.println( "period: " + period );

प्रस्तुत करता है:

period: PT4H30M
— तुलसी Bourque
स्रोत
यह हास्यास्पद है कि आपने "tl; डॉ।" के साथ पाठ की एक अप्रासंगिक-से-प्रश्न दीवार शुरू की है। सवाल यह नहीं है कि एक्स पहले से या समय की एक्स इकाइयों में टाइमस्टैम्प कैसे प्राप्त करें, लेकिन दो तिथियों के बीच डेल्टा कैसे प्राप्त करें। बस।
— बफेलो
@ बफलो मुझे आपकी टिप्पणी समझ नहीं आ रही है। मेरे उत्तर में शामिल हैं Period, Durationऔर ChronoUnit, तीन कक्षाएं जिनका उद्देश्य समय के बिंदुओं के बीच डेल्टा का निर्धारण करना है। कृपया इंगित करें कि मेरे "पाठ की दीवार" के कौन से हिस्से अप्रासंगिक हैं। और आप यह कहने में गलत हैं कि प्रश्न "तारीखों के बीच डेल्टा" के लिए कहा गया है: प्रश्न Dateउस कक्षा के दुर्भाग्यपूर्ण नामकरण के बावजूद, वस्तुओं के बीच एक डेल्टा के लिए पूछा गया है , जो तारीख-समय के क्षण हैं, "तारीख" नहीं।
— तुलसी बॉर्क
आपकी टिप्पणी में कुछ भी नहीं है जो दो मौजूदा java.util.Date ऑब्जेक्ट्स को हैंडल करता है। मैंने अपने कोड में विभिन्न स्निपेट का उपयोग करने की कोशिश की और कुछ भी नहीं मिला जो कि java.util.Date ऑब्जेक्ट का उपयोग करता है।
— बफेलो
@ बफैलो फेयर काफी, अच्छी आलोचना। मैंने java.util.Dateएक Instant(सिर्फ कॉल .toInstant) से परिवर्तित करने वाले "tl; डॉ।" अनुभाग में कोड जोड़ा । और मैंने Momentसमझाने के लिए अनुभाग जोड़ा । आपने एक जोड़ी Dateवस्तुओं का उल्लेख किया है , लेकिन वास्तव में प्रश्न केवल एक ही मौजूदा Dateवस्तु का उपयोग करता है और फिर वर्तमान क्षण को कैप्चर करता है, इसलिए मैंने ऐसा ही किया। प्रतिक्रिया के लिए धन्यवाद! टिप: उपयोग करने पर छोड़ दें Date- वे विरासत कक्षाएं वास्तव में एक भयानक मनहूस गड़बड़ हैं।
— बेसिल बॉर्क
23

थोड़ा सरल विकल्प: 

System.currentTimeMillis() - oldDate.getTime()

"अच्छे" के लिए: ठीक है, आपको वास्तव में क्या चाहिए? समय की संख्या और घंटों आदि के रूप में समय की अवधि का प्रतिनिधित्व करने के साथ समस्या यह है कि यह तारीखों की जटिलता के कारण गलतियां और गलत उम्मीदें पैदा कर सकती हैं (जैसे दिन दिन की बचत समय के कारण 23 या 25 घंटे हो सकते हैं)।

— माइकल बोर्गवर्ड
स्रोत
22

मिलीसेकंड दृष्टिकोण का उपयोग करने से कुछ स्थानों में समस्याएं हो सकती हैं।

उदाहरण के लिए, दो तारीखों के बीच अंतर 03/24/2007 और 03/25/2007 को 1 दिन होना चाहिए;

हालाँकि, मिलीसेकंड मार्ग का उपयोग करने पर, आपको 0 दिन मिलेंगे, यदि आप इसे यूके में चलाते हैं! 

/** Manual Method - YIELDS INCORRECT RESULTS - DO NOT USE**/  
/* This method is used to find the no of days between the given dates */  
public long calculateDays(Date dateEarly, Date dateLater) {  
   return (dateLater.getTime() - dateEarly.getTime()) / (24 * 60 * 60 * 1000);  
}

इसे लागू करने का बेहतर तरीका java.util.Calendar का उपयोग करना है

/** Using Calendar - THE CORRECT WAY**/  
public static long daysBetween(Calendar startDate, Calendar endDate) {  
  Calendar date = (Calendar) startDate.clone();  
  long daysBetween = 0;  
  while (date.before(endDate)) {  
    date.add(Calendar.DAY_OF_MONTH, 1);  
    daysBetween++;  
  }  
  return daysBetween;  
}
— zasadnyy
स्रोत
19
क्या आप कृपया इस कोड के मूल लेखक और तीसरे वाक्य को क्रेडिट कर सकते हैं, जिनकी ब्लॉग प्रविष्टि 2007 तक वापस आ गई है ?
— ०५ बजे व्रचगिन
क्या यह थोड़ा अप्रभावी नहीं है?
— गंगनुस ११'१३ को
यह सही ढंग से काम नहीं करता है। दिनबेटन (नया ग्रेगोरियन कैलेन्डर (2014,03,01), नया ग्रेगोरियन कैलेन्डर (2014,04,02)); 31 देता है, और इसे 32 वापस आना चाहिए: timeanddate.com/date/…
— marcolopes
5
@marcolopes - आप गलत हैं - क्योंकि कैलेंडर महीने शून्य आधारित हैं। मुझे यकीन है कि आप मार्च / अप्रैल का अर्थ कर रहे हैं, लेकिन आप जो परीक्षण कर रहे हैं वह अप्रैल / जून है जो 31 है। इसे सुरक्षित लिखने के लिए जैसे -> नया ग्रेगोरियन कैलेन्डर (2014, Calendar.MARCH, 1) ....
— चाचा इरोह
@UncleIroh, आप सही कह रहे हैं! मुझे याद आया कि महत्वपूर्ण तथ्य (कैलेंडर महीने शून्य आधारित हैं)। मुझे इस प्रश्न की फिर से समीक्षा करनी है।
— मार्कोलोप्स
22

ऐसे कई तरीके हैं जिनसे आप तिथियों और समय के बीच अंतर पा सकते हैं। सबसे सरल तरीकों में से एक है जो मुझे पता है:

      Calendar calendar1 = Calendar.getInstance();
      Calendar calendar2 = Calendar.getInstance();
      calendar1.set(2012, 04, 02);
      calendar2.set(2012, 04, 04);
      long milsecs1= calendar1.getTimeInMillis();
      long milsecs2 = calendar2.getTimeInMillis();
      long diff = milsecs2 - milsecs1;
      long dsecs = diff / 1000;
      long dminutes = diff / (60 * 1000);
      long dhours = diff / (60 * 60 * 1000);
      long ddays = diff / (24 * 60 * 60 * 1000);

      System.out.println("Your Day Difference="+ddays);

प्रिंट स्टेटमेंट सिर्फ एक उदाहरण है - आप इसे प्रारूपित कर सकते हैं, जिस तरह से आप चाहते हैं।

— JDGuide
स्रोत
5
@ मनोज कुमार बर्धन: स्टैक ओवरफ्लो में आपका स्वागत है: जैसा कि आप देखते हैं कि प्रश्न और उत्तर वर्षों पुराने हैं। आपके उत्तर को मौजूदा लोगों की तुलना में प्रश्न / उत्तर में अधिक जोड़ना चाहिए।
— जयन
3
उन दिनों के बारे में जो एक डीएसटी संक्रमण के कारण 23 या 25 घंटे हैं?
— जोनी
19

चूँकि यहाँ सभी उत्तर सही हैं, लेकिन जाड़ा या इसी तरह की विरासत जावा या 3 जी पार्टी लिबास का उपयोग करें, मैं सिर्फ जावा 8 और बाद में नए जावा.टाइम कक्षाओं का उपयोग करके एक और तरीका छोड़ दूंगा । ओरेकल ट्यूटोरियल देखें ।

उपयोग LocalDateऔर ChronoUnit:

LocalDate d1 = LocalDate.of(2017, 5, 1);
LocalDate d2 = LocalDate.of(2017, 5, 18);

long days = ChronoUnit.DAYS.between(d1, d2);
System.out.println( days );
— ΦXocツ 웃 Пepeúpa ę
स्रोत
9

मिलिसेकंड कार्य में तिथियों को घटाना (जैसा कि किसी अन्य पोस्ट में वर्णित है), लेकिन आपको अपनी तिथियों के समय भागों को साफ़ करते समय HOUR_OF_DAY का उपयोग करना होगा , न कि HOUR का उपयोग करना होगा:

public static final long MSPERDAY = 60 * 60 * 24 * 1000;
...
final Calendar dateStartCal = Calendar.getInstance();
dateStartCal.setTime(dateStart);
dateStartCal.set(Calendar.HOUR_OF_DAY, 0); // Crucial.
dateStartCal.set(Calendar.MINUTE, 0);
dateStartCal.set(Calendar.SECOND, 0);
dateStartCal.set(Calendar.MILLISECOND, 0);
final Calendar dateEndCal = Calendar.getInstance();
dateEndCal.setTime(dateEnd);
dateEndCal.set(Calendar.HOUR_OF_DAY, 0); // Crucial.
dateEndCal.set(Calendar.MINUTE, 0);
dateEndCal.set(Calendar.SECOND, 0);
dateEndCal.set(Calendar.MILLISECOND, 0);
final long dateDifferenceInDays = ( dateStartCal.getTimeInMillis()
                                  - dateEndCal.getTimeInMillis()
                                  ) / MSPERDAY;
if (dateDifferenceInDays > 15) {
    // Do something if difference > 15 days
}
— मैल्कम बोकेहॉफ
स्रोत
1
मानक पुस्तकालयों के बाहर जाने के बिना, दो कैलेंडर तिथियों के बीच अंतर को निर्धारित करने का यह सबसे अच्छा तरीका है। अधिकांश अन्य उत्तर एक दिन को 24 घंटे की मनमानी मानते हैं। यदि लीप सेकंड को कभी जोड़ा जाने के बजाय घटाया जाता है, तो अंतिम गणना ट्रंकेशन के कारण बंद हो सकती है, क्योंकि पूर्ण अंतर MSPERDAY के कई गुणा से थोड़ा कम हो सकता है।
— जूलियनसिम्स
8

यदि आप JodaTime या इसी तरह का उपयोग नहीं करना चाहते हैं, तो सबसे अच्छा उपाय शायद यही है:

final static long MILLIS_PER_DAY = 24 * 3600 * 1000;
long msDiff= date1.getTime() - date2.getTime();
long daysDiff = Math.round(msDiff / ((double)MILLIS_PER_DAY));

एमएस प्रति दिन की संख्या हमेशा समान नहीं होती है (दिन के समय की बचत के समय और लीप सेकंड के कारण), लेकिन यह बहुत करीब है, और दिन के समय की बचत के कारण कम से कम विचलन अधिक समय तक रद्द हो जाते हैं। इसलिए विभाजन और फिर गोलाई एक सही परिणाम देगा (कम से कम जब तक उपयोग किए जाने वाले स्थानीय कैलेंडर में डीएसटी और लीप सेकंड के अलावा अजीब समय कूद नहीं होता है)।

ध्यान दें कि यह अभी भी मानता है date1और date2दिन के एक ही समय पर सेट है। दिन के अलग-अलग समय के लिए, आपको सबसे पहले परिभाषित करना होगा कि जॉन स्कीट द्वारा बताए अनुसार "तिथि अंतर" क्या है।

— sleske
स्रोत
मुद्दा date1.getTime()बनाम में है date2.getTime()। तो 2016-03-03 से 2016-03-31 तक अलग-अलग 27 दिन गणना करेंगे जबकि आप 28 दिन चाहते हैं।
— मलत
@मलत: क्षमा करें, मैं अनुसरण नहीं कर सकता। मैंने अभी इसकी कोशिश की है - मेरे कोड 28 दिनों की गणना के साथ 2016-03-03 से 2016-03-31 तक। यदि यह आपके उदाहरण में कुछ और गणना करता है, तो उसे एक अलग प्रश्न के रूप में पूछें।
— स्लेस्के
इसके अलावा, क्या आपने मेरा कैविटी पढ़ा है? "यह अभी भी मानता है कि तारीख 1 और तारीख 2 दिन के एक ही समय के लिए निर्धारित हैं"। क्या आपने अपने परीक्षण में दिन के अलग-अलग समय का उपयोग किया था?
— सलके
ओह सही ! मुझे वह चाल याद आ गई Math.round(), जो 'वास्तविक दुनिया' कैलेंडर में सुरक्षित लगती है। शोर के लिए क्षमा करें।
— मलत
8

Joda Time पर एक नज़र डालें , जो Java के लिए एक बेहतर Date / Time API है और स्कैला के साथ ठीक काम करना चाहिए।

— रोब एच
स्रोत
जावा 8 में java.time (JSR-310) द्वारा प्रतिस्थापित
— malat
5

मुझे जोडा अंतराल और दिनों के बीच अंतर दिखाने दें:

DateTime start = new DateTime(2012, 2, 6, 10, 44, 51, 0);
DateTime end = new DateTime(2012, 2, 6, 11, 39, 47, 1);
Interval interval = new Interval(start, end);
Period period = interval.toPeriod();
System.out.println(period.getYears() + " years, " + period.getMonths() + " months, " + period.getWeeks() + " weeks, " + period.getDays() + " days");
System.out.println(period.getHours() + " hours, " + period.getMinutes() + " minutes, " + period.getSeconds() + " seconds ");
//Result is:
//0 years, 0 months, *1 weeks, 1 days*
//0 hours, 54 minutes, 56 seconds 

//Period can set PeriodType,such as PeriodType.yearMonthDay(),PeriodType.yearDayTime()...
Period p = new Period(start, end, PeriodType.yearMonthDayTime());
System.out.println(p.getYears() + " years, " + p.getMonths() + " months, " + p.getWeeks() + " weeks, " + p.getDays() + "days");
System.out.println(p.getHours() + " hours, " + p.getMinutes() + " minutes, " + p.getSeconds() + " seconds ");
//Result is:
//0 years, 0 months, *0 weeks, 8 days*
//0 hours, 54 minutes, 56 seconds
— user674158
स्रोत
5

यदि आपको "2 दिन 03h 42 मी 07" जैसे स्ट्रिंग स्वरूपित रिटर्न की आवश्यकता है, तो यह प्रयास करें:

public String fill2(int value)
{
    String ret = String.valueOf(value);

    if (ret.length() < 2)
        ret = "0" + ret;            
    return ret;
}

public String get_duration(Date date1, Date date2)
{                   
    TimeUnit timeUnit = TimeUnit.SECONDS;

    long diffInMilli = date2.getTime() - date1.getTime();
    long s = timeUnit.convert(diffInMilli, TimeUnit.MILLISECONDS);

    long days = s / (24 * 60 * 60);
    long rest = s - (days * 24 * 60 * 60);
    long hrs = rest / (60 * 60);
    long rest1 = rest - (hrs * 60 * 60);
    long min = rest1 / 60;      
    long sec = s % 60;

    String dates = "";
    if (days > 0) dates = days + " Days ";

    dates += fill2((int) hrs) + "h ";
    dates += fill2((int) min) + "m ";
    dates += fill2((int) sec) + "s ";

    return dates;
}
— इंगो
स्रोत
2
वाह, क्यों रोल अपनी खुद की जब Joda समय प्रदान करता है अवधि वर्ग पहले से ही लिखा गया है और डिबग?
— तुलसी बॉर्क
8
मुझे 4.1 MB की संकुचित फ़ाइल के साथ एक लाइब्रेरी क्यों डाउनलोड करनी चाहिए और इसे अपने प्रोजेक्ट में जोड़ना चाहिए, जब मुझे कोड की केवल 32 लाइनें चाहिए ???
— इंगो
1
क्योंकि जोडा-टाइम आलू के चिप्स की तरह है: आप सिर्फ एक नहीं खा सकते। आप सभी जगह पर Joda-Time का उपयोग करेंगे। और क्योंकि Joda-Time अच्छी तरह से जांचा और अच्छी तरह से पहना हुआ कोड है। और क्योंकि जोडा-टाइम पार्स करता है और मानक आईएसओ 8601 अवधि के तार उत्पन्न करता है जो इन मूल्यों को क्रमबद्ध या रिपोर्ट करने के लिए उपयोगी हो सकता है। और क्योंकि जोडा-टाइम में इन मूल्यों के स्थानीयकृत प्रतिनिधित्व को प्रिंट करने के लिए फॉर्मेटर्स शामिल हैं।
— तुलसी बोर्क
आपके सभी कोड का परीक्षण नहीं किया गया है। stdऊपर अपरिभाषित है।
— बेसिल बोर्क
@ बासिल बोर्के: संकेत के लिए Thx। मैंने स्रोत को निखारा है। यह त्रुटि अनुवाद से अंग्रेजी में आई।
— इंगो
5

नोट: startDate और endDates हैं -> java.util.Date 

import org.joda.time.Duration;
import org.joda.time.Interval;
// Use .getTime() unless it is a joda DateTime object
Interval interval = new Interval(startDate.getTime(), endDate.getTime());
Duration period = interval.toDuration();
//gives the number of days elapsed between start 
period.getStandardDays();

और अंतिम तिथि

दिनों के समान, आप घंटे, मिनट और सेकंड भी प्राप्त कर सकते हैं

period.getStandardHours();
period.getStandardMinutes();
period.getStandardSeconds();
— श्रवण राममूर्ति
स्रोत
4

यहाँ उदाहरण देखें http://www.roseindia.net/java/beginners/DateDifferent.shtml यह उदाहरण आपको दिन, घंटे, मिनट, सेकंड और मिल सेक के :) में अंतर देता है।

import java.util.Calendar;
import java.util.Date;

public class DateDifferent {
    public static void main(String[] args) {
        Date date1 = new Date(2009, 01, 10);
        Date date2 = new Date(2009, 07, 01);
        Calendar calendar1 = Calendar.getInstance();
        Calendar calendar2 = Calendar.getInstance();
        calendar1.setTime(date1);
        calendar2.setTime(date2);
        long milliseconds1 = calendar1.getTimeInMillis();
        long milliseconds2 = calendar2.getTimeInMillis();
        long diff = milliseconds2 - milliseconds1;
        long diffSeconds = diff / 1000;
        long diffMinutes = diff / (60 * 1000);
        long diffHours = diff / (60 * 60 * 1000);
        long diffDays = diff / (24 * 60 * 60 * 1000);
        System.out.println("\nThe Date Different Example");
        System.out.println("Time in milliseconds: " + diff + " milliseconds.");
        System.out.println("Time in seconds: " + diffSeconds + " seconds.");
        System.out.println("Time in minutes: " + diffMinutes + " minutes.");
        System.out.println("Time in hours: " + diffHours + " hours.");
        System.out.println("Time in days: " + diffDays + " days.");
    }
}
— Yok
स्रोत
3
-1 यह गलत है जब तक कि दिनांक उदाहरण UTC समय से प्राप्त नहीं किए गए थे। जॉन स्कीट का उत्तर देखें।
— sleske
4

कैलेंडर का एक उदाहरण प्राप्त करने के लिए GMT टाइम ज़ोन का उपयोग करें, कैलेंडर क्लास की सेट विधि का उपयोग करके समय निर्धारित करें। GMT टाइमज़ोन में 0 ऑफसेट (वास्तव में महत्वपूर्ण नहीं है) और डेलाइट सेविंग टाइम फ्लैग को झूठा सेट किया गया है।

    final Calendar cal = Calendar.getInstance(TimeZone.getTimeZone("GMT"));

    cal.set(Calendar.YEAR, 2011);
    cal.set(Calendar.MONTH, 9);
    cal.set(Calendar.DAY_OF_MONTH, 29);
    cal.set(Calendar.HOUR, 0);
    cal.set(Calendar.MINUTE, 0);
    cal.set(Calendar.SECOND, 0);
    final Date startDate = cal.getTime();

    cal.set(Calendar.YEAR, 2011);
    cal.set(Calendar.MONTH, 12);
    cal.set(Calendar.DAY_OF_MONTH, 21);
    cal.set(Calendar.HOUR, 0);
    cal.set(Calendar.MINUTE, 0);
    cal.set(Calendar.SECOND, 0);
    final Date endDate = cal.getTime();

    System.out.println((endDate.getTime() - startDate.getTime()) % (1000l * 60l * 60l * 24l));
— मीकल
स्रोत
मिलीसेकंड भाग को शून्य करने के लिए मत भूलना यह पुरानी कक्षाओं java.util.Dateआदि के संदर्भ में एक अच्छा जवाब है । जीएमटी को टाइमजोन सेट करने के लिए हैक का उपयोग दिन की बचत के प्रभावों के लिए कोड को असंवेदनशील बनाता है।
— मेनो होच्स्चिल
4

निम्नलिखित कोड आपको वांछित आउटपुट दे सकता है:

String startDate = "Jan 01 2015";
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MMM dd yyyy");
LocalDate date = LocalDate.parse(startDate, formatter);

String currentDate = "Feb 11 2015";
LocalDate date1 = LocalDate.parse(currentDate, formatter);

System.out.println(date1.toEpochDay() - date.toEpochDay());
— विशाल गंजारे
स्रोत
3
क्या आप बता सकते हैं कि आपका कोड वास्तव में क्या करता है? लगता है कि प्रश्न एक समय डेल्टा के बारे में पूछ रहा है और, पहली नज़र में, आपका कोड एक दिन का डेल्टा लौटाएगा?
— जीएचसी
4 
public static String getDifferenceBtwTime(Date dateTime) {

    long timeDifferenceMilliseconds = new Date().getTime() - dateTime.getTime();
    long diffSeconds = timeDifferenceMilliseconds / 1000;
    long diffMinutes = timeDifferenceMilliseconds / (60 * 1000);
    long diffHours = timeDifferenceMilliseconds / (60 * 60 * 1000);
    long diffDays = timeDifferenceMilliseconds / (60 * 60 * 1000 * 24);
    long diffWeeks = timeDifferenceMilliseconds / (60 * 60 * 1000 * 24 * 7);
    long diffMonths = (long) (timeDifferenceMilliseconds / (60 * 60 * 1000 * 24 * 30.41666666));
    long diffYears = (long)(timeDifferenceMilliseconds / (1000 * 60 * 60 * 24 * 365));

    if (diffSeconds < 1) {
        return "one sec ago";
    } else if (diffMinutes < 1) {
        return diffSeconds + " seconds ago";
    } else if (diffHours < 1) {
        return diffMinutes + " minutes ago";
    } else if (diffDays < 1) {
        return diffHours + " hours ago";
    } else if (diffWeeks < 1) {
        return diffDays + " days ago";
    } else if (diffMonths < 1) {
        return diffWeeks + " weeks ago";
    } else if (diffYears < 12) {
        return diffMonths + " months ago";
    } else {
        return diffYears + " years ago";
    }
}
— पार्थ सोलंकी
स्रोत
3 
int daysDiff = (date1.getTime() - date2.getTime()) / MILLIS_PER_DAY;
— Bozho
स्रोत
5
-1 यह गलत है जब तक कि दिनांक उदाहरण UTC समय से प्राप्त नहीं किए गए थे। जॉन स्कीट का उत्तर देखें।
— sleske
5
@ आप सही नहीं हैं। उन्होंने समय-समय पर सूचनाओं का उपयोग करके खो दिया है Date, इसलिए यह तुलना सबसे अच्छी है जिसे परिस्थितियों को देखते हुए हासिल किया जा सकता है।
— Bozho
1
ठीक है, लगता है कि हम दोनों सही हैं। यह सच है कि यह इस बात पर निर्भर करता है कि दिनांक उदाहरण कहाँ से आता है। फिर भी, यह इतनी सामान्य गलती है कि इसका उल्लेख किया जाना चाहिए।
— sleske
जब मैं आपके समाधान का उपयोग करता हूं, तो यह कहता है: प्रकार बेमेल: लंबे समय से इंट में परिवर्तित नहीं हो सकता। मुझे लगता है कि आपको भी कास्टिंग को जोड़ना चाहिए या क्या मुझे कुछ याद आ रहा है?
— विज्ञापन Infinitum
3

सबसे अच्छी बात यह है कि

(Date1-Date2)/86 400 000

वह संख्या मिलीसेकंड की संख्या है एक दिन में है।

एक तारीख-दूसरी तारीख आपको मिलीसेकंड में अंतर देती है।

दोहरे चर में उत्तर लीजिए ।

— रेवंत कुमार
स्रोत
हाँ क्यों नहीं? मैं कुछ मायनों में प्रश्न के बिंदु को नहीं समझता: ओपी को एमएस में अंतर होता है ... और एक दिन में निश्चित संख्या में एमएस होते हैं (एक नीला चंद्रमा में एक बार कुछ खगोलीय समायोजन के साथ ठीक है, लेकिन ओपी doesn 'टी का कहना है कि यह उतना ही सटीक होना चाहिए जितना खगोलविदों को इसकी आवश्यकता है ...)
— माइक कृंतक
3

यहां ओ (1) में बिना किसी निर्भरता के एक सही जावा 7 समाधान है।

public static int countDaysBetween(Date date1, Date date2) {

    Calendar c1 = removeTime(from(date1));
    Calendar c2 = removeTime(from(date2));

    if (c1.get(YEAR) == c2.get(YEAR)) {

        return Math.abs(c1.get(DAY_OF_YEAR) - c2.get(DAY_OF_YEAR)) + 1;
    }
    // ensure c1 <= c2
    if (c1.get(YEAR) > c2.get(YEAR)) {
        Calendar c = c1;
        c1 = c2;
        c2 = c;
    }
    int y1 = c1.get(YEAR);
    int y2 = c2.get(YEAR);
    int d1 = c1.get(DAY_OF_YEAR);
    int d2 = c2.get(DAY_OF_YEAR);

    return d2 + ((y2 - y1) * 365) - d1 + countLeapYearsBetween(y1, y2) + 1;
}

private static int countLeapYearsBetween(int y1, int y2) {

    if (y1 < 1 || y2 < 1) {
        throw new IllegalArgumentException("Year must be > 0.");
    }
    // ensure y1 <= y2
    if (y1 > y2) {
        int i = y1;
        y1 = y2;
        y2 = i;
    }

    int diff = 0;

    int firstDivisibleBy4 = y1;
    if (firstDivisibleBy4 % 4 != 0) {
        firstDivisibleBy4 += 4 - (y1 % 4);
    }
    diff = y2 - firstDivisibleBy4 - 1;
    int divisibleBy4 = diff < 0 ? 0 : diff / 4 + 1;

    int firstDivisibleBy100 = y1;
    if (firstDivisibleBy100 % 100 != 0) {
        firstDivisibleBy100 += 100 - (firstDivisibleBy100 % 100);
    }
    diff = y2 - firstDivisibleBy100 - 1;
    int divisibleBy100 = diff < 0 ? 0 : diff / 100 + 1;

    int firstDivisibleBy400 = y1;
    if (firstDivisibleBy400 % 400 != 0) {
        firstDivisibleBy400 += 400 - (y1 % 400);
    }
    diff = y2 - firstDivisibleBy400 - 1;
    int divisibleBy400 = diff < 0 ? 0 : diff / 400 + 1;

    return divisibleBy4 - divisibleBy100 + divisibleBy400;
}


public static Calendar from(Date date) {

    Calendar c = Calendar.getInstance();
    c.setTime(date);

    return c;
}


public static Calendar removeTime(Calendar c) {

    c.set(HOUR_OF_DAY, 0);
    c.set(MINUTE, 0);
    c.set(SECOND, 0);
    c.set(MILLISECOND, 0);

    return c;
}
— suxumuxu
स्रोत
2

शायद ऐसा करने का सबसे सरल तरीका है - शायद ऐसा इसलिए है क्योंकि मैं जावा में कोडिंग कर रहा हूं (अब कुछ समय के लिए इसकी क्लूनी काफ़ी समय और लाइब्रेरीज़ के साथ), लेकिन वह कोड मुझे "सरल और अच्छा" लगता है!

क्या आप मिलीसेकंड में दिए गए परिणाम से खुश हैं, या आपके सवाल का हिस्सा है कि आप इसे कुछ वैकल्पिक प्रारूप में वापस करना पसंद करेंगे?

— आंद्रेज डॉयल
स्रोत
2

मानक एपीआई का उपयोग नहीं, नहीं। आप अपना खुद का रोल कुछ इस तरह से कर सकते हैं:

class Duration {
    private final TimeUnit unit;
    private final long length;
    // ...
}

या आप जोडा का उपयोग कर सकते हैं :

DateTime a = ..., b = ...;
Duration d = new Duration(a, b);
— gustafc
स्रोत
2

प्रारंभिक प्रश्न का उत्तर देने के लिए:

निम्न कोड को लंबे गेटएज () {} जैसे फ़ंक्शन में रखें

Date dahora = new Date();
long MillisToYearsByDiv = 1000l *60l * 60l * 24l * 365l;
long javaOffsetInMillis = 1990l * MillisToYearsByDiv;
long realNowInMillis = dahora.getTime() + javaOffsetInMillis;
long realBirthDayInMillis = this.getFechaNac().getTime() + javaOffsetInMillis;
long ageInMillis = realNowInMillis - realBirthDayInMillis;

return ageInMillis / MillisToYearsByDiv;

सबसे महत्वपूर्ण यहां गुणा और विभाजन करते समय लंबी संख्या के साथ काम करना है। और हां, जावा के अपने कैलकुलस में जो ऑफसेट लागू होता है।

:)

— मुगिवारा नो कार्लोस
स्रोत
2

चूंकि प्रश्न स्केल के साथ टैग किया गया है,

import scala.concurrent.duration._
val diff = (System.currentTimeMillis() - oldDate.getTime).milliseconds
val diffSeconds = diff.toSeconds
val diffMinutes = diff.toMinutes
val diffHours = diff.toHours
val diffDays = diff.toDays
— VasiliNovikov
स्रोत
2

जावा 7 दिनांक प्रकार रखने के लिए अन्य सभी उत्तरों के माध्यम से लुप्त होने के बाद, लेकिन जावा 8 भिन्न दृष्टिकोण के साथ अधिक सटीक / मानक हो,

public static long daysBetweenDates(Date d1, Date d2) {
    Instant instant1 = d1.toInstant();
    Instant instant2 = d2.toInstant();
    long diff = ChronoUnit.DAYS.between(instant1, instant2);
    return diff;
}
— जीन बी।
स्रोत
1

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

int epoch = (int) (new java.text.SimpleDateFormat("MM/dd/yyyy HH:mm:ss").parse("01/01/1970  00:00:00").getTime() / 1000);

आप पार्स () विधियों में स्ट्रिंग को संपादित कर सकते हैं।

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