जावा में दो तिथियों के बीच के दिनों में अंतर?

Question 1

मुझे दो तिथियों के बीच दिनों की संख्या खोजने की आवश्यकता है : एक रिपोर्ट से है और एक वर्तमान तिथि से है। मेरा स्निपेट:

  int age=calculateDifference(agingDate, today);

यहाँ calculateDifferenceएक निजी तरीका है, agingDateऔर todayकर रहे हैं Dateबस अपने स्पष्टीकरण के लिए, वस्तुओं। मैंने जावा मंच से दो लेखों का अनुसरण किया है, थ्रेड 1 / थ्रेड 2 ।

यह एक स्वसंपूर्ण कार्यक्रम में ठीक काम करता है, हालांकि जब मैं रिपोर्ट में पढ़ने के लिए अपने तर्क में इसे शामिल करता हूं तो मुझे मूल्यों में एक असामान्य अंतर मिलता है।

यह क्यों हो रहा है और मैं इसे कैसे ठीक कर सकता हूं?

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

मुझे वास्तविक दिनों की तुलना में अधिक दिनों की संख्या मिल रही है।

public static int calculateDifference(Date a, Date b)
{
    int tempDifference = 0;
    int difference = 0;
    Calendar earlier = Calendar.getInstance();
    Calendar later = Calendar.getInstance();

    if (a.compareTo(b) < 0)
    {
        earlier.setTime(a);
        later.setTime(b);
    }
    else
    {
        earlier.setTime(b);
        later.setTime(a);
    }

    while (earlier.get(Calendar.YEAR) != later.get(Calendar.YEAR))
    {
        tempDifference = 365 * (later.get(Calendar.YEAR) - earlier.get(Calendar.YEAR));
        difference += tempDifference;

        earlier.add(Calendar.DAY_OF_YEAR, tempDifference);
    }

    if (earlier.get(Calendar.DAY_OF_YEAR) != later.get(Calendar.DAY_OF_YEAR))
    {
        tempDifference = later.get(Calendar.DAY_OF_YEAR) - earlier.get(Calendar.DAY_OF_YEAR);
        difference += tempDifference;

        earlier.add(Calendar.DAY_OF_YEAR, tempDifference);
    }

    return difference;
}

ध्यान दें :

दुर्भाग्य से, किसी भी उत्तर ने मुझे समस्या को हल करने में मदद नहीं की। मैंने इस समस्या को जोडा-टाइम लाइब्रेरी की मदद से पूरा किया है ।

Question 2

मेरा सुझाव है कि आप त्रुटिपूर्ण java.util.Date और दोस्तों के बजाय उत्कृष्ट Joda Time लाइब्रेरी का उपयोग करें। आप बस लिख सकते हैं

import java.util.Date;
import org.joda.time.DateTime;
import org.joda.time.Days;

Date past = new Date(110, 5, 20); // June 20th, 2010
Date today = new Date(110, 6, 24); // July 24th 
int days = Days.daysBetween(new DateTime(past), new DateTime(today)).getDays(); // => 34

Question 3

मुझे खेल में शामिल होने में बहुत देर हो सकती है, लेकिन क्या बात है? :)

क्या आपको लगता है कि यह एक मुद्दा है? उदाहरण के लिए आप इस विधि के आउटपुट का उपयोग कैसे कर रहे हैं? या

क्या हम कुछ के रूप में सरल करने के लिए अपना कोड बदल सकते हैं:

Calendar calendar1 = Calendar.getInstance();
    Calendar calendar2 = Calendar.getInstance();
    calendar1.set(<your earlier date>);
    calendar2.set(<your current date>);
    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.");
  }

Question 4

अंतर / (24 * आदि) टाइमज़ोन को ध्यान में नहीं रखता है, इसलिए यदि आपके डिफ़ॉल्ट टाइमज़ोन में डीएसटी है, तो यह गणना को बंद कर सकता है।

इस लिंक पर एक अच्छा सा कार्यान्वयन है।

यहाँ लिंक ऊपर जाने की स्थिति में उपरोक्त लिंक का स्रोत है:

/** Using Calendar - THE CORRECT WAY**/  
public static long daysBetween(Calendar startDate, Calendar endDate) {  
  //assert: startDate must be before endDate  
  Calendar date = (Calendar) startDate.clone();  
  long daysBetween = 0;  
  while (date.before(endDate)) {  
    date.add(Calendar.DAY_OF_MONTH, 1);  
    daysBetween++;  
  }  
  return daysBetween;  
}

तथा

/** Using Calendar - THE CORRECT (& Faster) WAY**/  
public static long daysBetween(final Calendar startDate, final Calendar endDate)
{
  //assert: startDate must be before endDate  
  int MILLIS_IN_DAY = 1000 * 60 * 60 * 24;  
  long endInstant = endDate.getTimeInMillis();  
  int presumedDays = 
    (int) ((endInstant - startDate.getTimeInMillis()) / MILLIS_IN_DAY);  
  Calendar cursor = (Calendar) startDate.clone();  
  cursor.add(Calendar.DAY_OF_YEAR, presumedDays);  
  long instant = cursor.getTimeInMillis();  
  if (instant == endInstant)  
    return presumedDays;

  final int step = instant < endInstant ? 1 : -1;  
  do {  
    cursor.add(Calendar.DAY_OF_MONTH, step);  
    presumedDays += step;  
  } while (cursor.getTimeInMillis() != endInstant);  
  return presumedDays;  
}

Question 5

java.time

जावा 8 और बाद में, java.time फ्रेमवर्क ( ट्यूटोरियल ) का उपयोग करें ।

`Duration`

Durationवर्ग सेकंड के एक नंबर के साथ साथ एक आंशिक दूसरे के रूप में समय के अंतराल का प्रतिनिधित्व करता है। यह दिन, घंटे, मिनट और सेकंड गिन सकता है।

ZonedDateTime now = ZonedDateTime.now();
ZonedDateTime oldDate = now.minusDays(1).minusMinutes(10);
Duration duration = Duration.between(oldDate, now);
System.out.println(duration.toDays());

`ChronoUnit`

यदि आप सभी की जरूरत है दिनों की संख्या है, वैकल्पिक रूप से आप एनम का उपयोग कर सकते हैं । ध्यान दें कि गणना के तरीके बदले के बजाय वापस आते हैं ।ChronoUnit longint

long days = ChronoUnit.DAYS.between( then, now );

Question 6

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

public class Main {
    public static long calculateDays(String startDate, String endDate)
    {
        Date sDate = new Date(startDate);
        Date eDate = new Date(endDate);
        Calendar cal3 = Calendar.getInstance();
        cal3.setTime(sDate);
        Calendar cal4 = Calendar.getInstance();
        cal4.setTime(eDate);
        return daysBetween(cal3, cal4);
    }

    public static void main(String[] args) {
        System.out.println(calculateDays("2012/03/31", "2012/06/17"));

    }

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

Question 7

यह इस बात पर निर्भर करता है कि आप अंतर के रूप में क्या परिभाषित करते हैं। आधी रात को दो तिथियों की तुलना करने के लिए आप कर सकते हैं।

long day1 = ...; // in milliseconds.
long day2 = ...; // in milliseconds.
long days = (day2 - day1) / 86400000;

Question 8

डीएसटी की तारीखों के लिए सही गोलाई के साथ, मिलिसेकंड समय के बीच अंतर का उपयोग करके समाधान:

public static long daysDiff(Date from, Date to) {
    return daysDiff(from.getTime(), to.getTime());
}

public static long daysDiff(long from, long to) {
    return Math.round( (to - from) / 86400000D ); // 1000 * 60 * 60 * 24
}

एक नोट: निश्चित रूप से, तिथियां कुछ समयक्षेत्र में होनी चाहिए।

महत्वपूर्ण कोड:

Math.round( (to - from) / 86400000D )

यदि आप गोल नहीं चाहते हैं, तो आप UTC दिनांक का उपयोग कर सकते हैं,

Question 9

समस्या का चित्रण: (मेरा कोड हफ्तों में डेल्टा की गणना कर रहा है, लेकिन दिनों में डेल्टा के साथ एक ही मुद्दा लागू होता है)

यहाँ एक बहुत ही उचित दिखने वाला कार्यान्वयन है:

public static final long MILLIS_PER_WEEK = 7L * 24L * 60L * 60L * 1000L;

static public int getDeltaInWeeks(Date latterDate, Date earlierDate) {
    long deltaInMillis = latterDate.getTime() - earlierDate.getTime();
    int deltaInWeeks = (int)(deltaInMillis / MILLIS_PER_WEEK);
    return deltaInWeeks; 
}

लेकिन यह परीक्षण विफल हो जाएगा:

public void testGetDeltaInWeeks() {
    delta = AggregatedData.getDeltaInWeeks(dateMar09, dateFeb23);
    assertEquals("weeks between Feb23 and Mar09", 2, delta);
}

कारण यह है की:

सोम मार्च 09 00:00:00 EDT 2009 = 1,236,571,200,000
सोम फरवरी 23 00:00:00 ईएसटी 2009 = 1,235,365,200,000
MillisPerWeek = 604,800,000
इस प्रकार,
(Mar09 - Feb23 / MillisPerWeek =
/ MillisPerWeek = 1,206,000,000 / 604,800,000 = 1.994 ...

लेकिन कैलेंडर को देखने वाला कोई भी व्यक्ति सहमत होगा कि उत्तर 2 है।

Question 10

मैं इस फफूंद का उपयोग करता हूं:

DATEDIFF("31/01/2016", "01/03/2016") // me return 30 days

मेरा कार्य:

import java.util.Date;

public long DATEDIFF(String date1, String date2) {
        long MILLISECS_PER_DAY = 24 * 60 * 60 * 1000;
        long days = 0l;
        SimpleDateFormat format = new SimpleDateFormat("dd/MM/yyyy"); // "dd/MM/yyyy HH:mm:ss");

        Date dateIni = null;
        Date dateFin = null;        
        try {       
            dateIni = (Date) format.parse(date1);
            dateFin = (Date) format.parse(date2);
            days = (dateFin.getTime() - dateIni.getTime())/MILLISECS_PER_DAY;                        
        } catch (Exception e) {  e.printStackTrace();  }   

        return days; 
     }

Question 11

को देखो getFragmentInDays इस Apache Commons-लैंग कक्षा में तरीकों DateUtils।

Question 12

@ Mad_Troll के उत्तर के आधार पर, मैंने इस पद्धति को विकसित किया।

मैंने इसके खिलाफ लगभग 30 परीक्षण मामले चलाए हैं, एकमात्र तरीका है जो सब डे टाइम अंशों को सही ढंग से संभालता है।

उदाहरण: यदि आप अभी और अभी + 1 मिलीसेकंड पार करते हैं, जो अभी भी एक ही दिन है। कर 1-1-13 23:59:59.098के 1-1-13 23:59:59.0990 दिन रिटर्न, सही ढंग से; यहां पोस्ट की गई अन्य विधियों का आवंटन सही ढंग से नहीं करेगा।

वर्थ नोटिंग यह परवाह नहीं करता है कि आप उन्हें किस तरीके से डालते हैं, यदि आपकी अंतिम तिथि आपकी शुरुआत की तारीख से पहले है तो यह पीछे की ओर गिना जाएगा।

/**
 * This is not quick but if only doing a few days backwards/forwards then it is very accurate.
 *
 * @param startDate from
 * @param endDate   to
 * @return day count between the two dates, this can be negative if startDate is after endDate
 */
public static long daysBetween(@NotNull final Calendar startDate, @NotNull final Calendar endDate) {

    //Forwards or backwards?
    final boolean forward = startDate.before(endDate);
    // Which direction are we going
    final int multiplier = forward ? 1 : -1;

    // The date we are going to move.
    final Calendar date = (Calendar) startDate.clone();

    // Result
    long daysBetween = 0;

    // Start at millis (then bump up until we go back a day)
    int fieldAccuracy = 4;
    int field;
    int dayBefore, dayAfter;
    while (forward && date.before(endDate) || !forward && endDate.before(date)) {
        // We start moving slowly if no change then we decrease accuracy.
        switch (fieldAccuracy) {
            case 4:
                field = Calendar.MILLISECOND;
                break;
            case 3:
                field = Calendar.SECOND;
                break;
            case 2:
                field = Calendar.MINUTE;
                break;
            case 1:
                field = Calendar.HOUR_OF_DAY;
                break;
            default:
            case 0:
                field = Calendar.DAY_OF_MONTH;
                break;
        }
        // Get the day before we move the time, Change, then get the day after.
        dayBefore = date.get(Calendar.DAY_OF_MONTH);
        date.add(field, multiplier);
        dayAfter = date.get(Calendar.DAY_OF_MONTH);

        // This shifts lining up the dates, one field at a time.
        if (dayBefore == dayAfter && date.get(field) == endDate.get(field))
            fieldAccuracy--;
        // If day has changed after moving at any accuracy level we bump the day counter.
        if (dayBefore != dayAfter) {
            daysBetween += multiplier;
        }
    }
    return daysBetween;
}

आप @NotNullएनोटेशन को हटा सकते हैं, इनका उपयोग Intellij द्वारा मक्खी पर कोड विश्लेषण करने के लिए किया जाता है

Question 13

आप कहते हैं कि "यह एक स्वसंपूर्ण कार्यक्रम में ठीक काम करता है," लेकिन जब आपको "असामान्य अंतर मान" मिलते हैं तो "आप इसे रिपोर्ट से पढ़ने के लिए मेरे तर्क में शामिल करते हैं"। यह बताता है कि आपकी रिपोर्ट में कुछ मान हैं जिनके लिए यह सही ढंग से काम नहीं करता है, और आपके स्टैंडअलोन प्रोग्राम में वे मान नहीं हैं। एक स्टैंडअलोन कार्यक्रम के बजाय, मैं एक परीक्षण मामले का सुझाव देता हूं। आप जितने भी स्टैंडअलोन प्रोग्राम करेंगे, एक टेस्ट केस लिखें, जो कि जुनेट के टेस्टकेस क्लास से उप-वर्ग हो। अब आप एक बहुत ही विशिष्ट उदाहरण चला सकते हैं, यह जानकर कि आप किस मूल्य की उम्मीद करते हैं (और आज इसे परीक्षण मूल्य के लिए नहीं देते हैं, क्योंकि आज समय के साथ बदलता है)। यदि आप स्टैंडअलोन प्रोग्राम में उपयोग किए गए मानों में डालते हैं, तो आपके परीक्षण संभवतः पास होंगे। यह बहुत अच्छा है - आप चाहते हैं कि वे मामले काम करते रहें। अब, अपनी रिपोर्ट से एक मूल्य जोड़ें, जो एक नहीं है ' t काम सही। आपका नया परीक्षण शायद विफल हो जाएगा। पता लगाएँ कि यह क्यों विफल हो रहा है, इसे ठीक करें, और हरे रंग में जाएं (सभी परीक्षण पास हो रहे हैं)। अपनी रिपोर्ट चलाएं। देखो क्या अभी भी टूट गया है; एक परीक्षण लिखें; इसे पास करो। बहुत जल्द आप पाएंगे कि आपकी रिपोर्ट काम कर रही है।

Question 14

इस मूल कार्य के लिए कोड की सौ पंक्तियाँ ???

बस एक सरल विधि:

protected static int calculateDayDifference(Date dateAfter, Date dateBefore){
    return (int)(dateAfter.getTime()-dateBefore.getTime())/(1000 * 60 * 60 * 24); 
    // MILLIS_IN_DAY = 1000 * 60 * 60 * 24;
}

Question 15

public static int getDifferenceIndays(long timestamp1, long timestamp2) {
    final int SECONDS = 60;
    final int MINUTES = 60;
    final int HOURS = 24;
    final int MILLIES = 1000;
    long temp;
    if (timestamp1 < timestamp2) {
        temp = timestamp1;
        timestamp1 = timestamp2;
        timestamp2 = temp;
    }
    Calendar startDate = Calendar.getInstance(TimeZone.getDefault());
    Calendar endDate = Calendar.getInstance(TimeZone.getDefault());
    endDate.setTimeInMillis(timestamp1);
    startDate.setTimeInMillis(timestamp2);
    if ((timestamp1 - timestamp2) < 1 * HOURS * MINUTES * SECONDS * MILLIES) {
        int day1 = endDate.get(Calendar.DAY_OF_MONTH);
        int day2 = startDate.get(Calendar.DAY_OF_MONTH);
        if (day1 == day2) {
            return 0;
        } else {
            return 1;
        }
    }
    int diffDays = 0;
    startDate.add(Calendar.DAY_OF_MONTH, diffDays);
    while (startDate.before(endDate)) {
        startDate.add(Calendar.DAY_OF_MONTH, 1);
        diffDays++;
    }
    return diffDays;
}

Question 16

ThreeTen-अतिरिक्त

विटाली Fedorenko द्वारा उत्तर कैसे के साथ एक आधुनिक तरीके से इस गणना के प्रदर्शन करने के लिए का वर्णन, सही है java.time वर्गों ( Durationऔर ChronoUnitजावा 8 में बनाया गया और बाद में) (और बैक-पोर्ट जावा 6 और 7 के लिए और Android के लिए )।

`Days`

यदि आप अपने कोड में नियमित रूप से कई दिनों का उपयोग कर रहे हैं, तो आप एक वर्ग के उपयोग के साथ मात्र पूर्णांकों को बदल सकते हैं। Daysकक्षा में पाया जा सकता है ThreeTen-अतिरिक्त , परियोजना java.time के लिए संभव भविष्य परिवर्धन के लिए java.time का एक विस्तार और मूलभूत। Daysवर्ग अपने आवेदन में दिनों की संख्या का प्रतिनिधित्व करने का एक प्रकार है-सुरक्षित तरीका प्रदान करता है। वर्ग में ZEROऔर के लिए सुविधाजनक स्थिरांक शामिल हैं ONE।

java.util.Dateप्रश्न में पुरानी पुरानी वस्तुओं को देखते हुए , पहले उन्हें आधुनिक java.time.Instantवस्तुओं में परिवर्तित करें । पुरानी तिथि-समय की कक्षाओं में java.time में रूपांतरण की सुविधा के लिए नए जोड़े गए तरीके हैं, जैसे कि java.util.Date::toInstant।

Instant start = utilDateStart.toInstant(); // Inclusive.
Instant stop = utilDateStop.toInstant();  // Exclusive.

दोनों Instantवस्तुओं को फैक्ट्री विधि के लिए पास करें org.threeten.extra.Days।

वर्तमान कार्यान्वयन (2016-06) में यह एक आवरण कॉलिंग है java.time.temporal.ChronoUnit.DAYS.between, ChronoUnitविवरण के लिए क्लास डॉक पढ़ें । स्पष्ट है: सभी बड़े DAYSenum में है ChronoUnit, जबकि प्रारंभिक-कैप DaysThreeTen-अतिरिक्त से एक वर्ग है।

Days days = Days.between( start , stop );

आप इन Daysऑब्जेक्ट्स को अपने कोड के आसपास पास कर सकते हैं । आप मानक ISO 8601 प्रारूप में एक स्ट्रिंग को क्रमबद्ध करके कॉल कर सकते हैं toString। इस प्रारूप का PnDउपयोग बीच में कई दिनों के साथ Pशुरुआत और D"दिन" को चिह्नित करने के लिए करता है । दोनों java.time क्लासेस और थ्रीटेन-एक्सट्रा डेट-टाइम वैल्यूज़ का प्रतिनिधित्व करने वाले स्ट्रिंग्स को जेनरेट और पार्स करते समय इन स्टैंडर्ड फॉर्मेट्स को डिफ़ॉल्ट रूप से इस्तेमाल करते हैं।

String output = days.toString();

P3D

Days days = Days.parse( "P3D" );

Question 17

यह कोड 2 तारीख स्ट्रिंग्स के बीच के दिनों की गणना करता है:

    static final long MILLI_SECONDS_IN_A_DAY = 1000 * 60 * 60 * 24;
    static final String DATE_FORMAT = "dd-MM-yyyy";
    public long daysBetween(String fromDateStr, String toDateStr) throws ParseException {
    SimpleDateFormat format = new SimpleDateFormat(DATE_FORMAT);
    Date fromDate;
    Date toDate;
    fromDate = format.parse(fromDateStr);
    toDate = format.parse(toDateStr);
    return (toDate.getTime() - fromDate.getTime()) / MILLI_SECONDS_IN_A_DAY;
}

Question 18

यदि आप एक ऐसे समाधान की तलाश कर रहे हैं जो उदाहरण के लिए उचित संख्या या दिन लौटाता है 11/30/2014 23:59और 12/01/2014 00:01यहां जोडा समय का उपयोग करके समाधान है।

private int getDayDifference(long past, long current) {
    DateTime currentDate = new DateTime(current);
    DateTime pastDate = new DateTime(past);
    return currentDate.getDayOfYear() - pastDate.getDayOfYear();
}

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

Question 19

आपको जावा टाइम लाइब्रेरी का उपयोग करना चाहिए क्योंकि जावा यूटिल डेट कभी-कभी गलत मान देता है।

Joda बनाम Java Util Date

उदाहरण के लिए कल (dd-mm-yyyy, 12-07-2016) और 1957 में वर्ष का पहला दिन (dd-mm-yyyy, 01-01-1957)

public class Main {

public static void main(String[] args) {
    SimpleDateFormat format = new SimpleDateFormat("dd-MM-yyyy");

    Date date = null;
    try {
        date = format.parse("12-07-2016");
    } catch (ParseException e) {
        e.printStackTrace();
    }

    //Try with Joda - prints 21742
    System.out.println("This is correct: " + getDaysBetweenDatesWithJodaFromYear1957(date));
    //Try with Java util - prints 21741
    System.out.println("This is not correct: " + getDaysBetweenDatesWithJavaUtilFromYear1957(date));    
}


private static int getDaysBetweenDatesWithJodaFromYear1957(Date date) {
    DateTime jodaDateTime = new DateTime(date);
    DateTimeFormatter formatter = DateTimeFormat.forPattern("dd-MM-yyyy");
    DateTime y1957 = formatter.parseDateTime("01-01-1957");

    return Days.daysBetween(y1957 , jodaDateTime).getDays();
}

private static long getDaysBetweenDatesWithJavaUtilFromYear1957(Date date) {
    SimpleDateFormat format = new SimpleDateFormat("dd-MM-yyyy");

    Date y1957 = null;
    try {
        y1957 = format.parse("01-01-1957");
    } catch (ParseException e) {
        e.printStackTrace();
    }

    return TimeUnit.DAYS.convert(date.getTime() - y1957.getTime(), TimeUnit.MILLISECONDS);
}

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

Question 20

मैंने इसे इस तरह किया। यह आसान है :)

Date d1 = jDateChooserFrom.getDate();
Date d2 = jDateChooserTo.getDate();

Calendar day1 = Calendar.getInstance();
day1.setTime(d1);

Calendar day2 = Calendar.getInstance();
day2.setTime(d2);

int from = day1.get(Calendar.DAY_OF_YEAR);
int to = day2.get(Calendar.DAY_OF_YEAR);

int difference = to-from;