Android / Java - दिनों में तारीख का अंतर

Question 1

नीचे दी गई कोड का उपयोग करके मुझे वर्तमान तिथि (प्रारूप 12/31/1999 अर्थात मिमी / dd / yyyy) मिल रही है:

Textview txtViewData;
txtViewDate.setText("Today is " +
        android.text.format.DateFormat.getDateFormat(this).format(new Date()));

और मेरे पास प्रारूप में एक और तारीख है: 2010-08-25 (यानी yyyy / mm / dd)

इसलिए मैं दिनों की संख्या के बीच अंतर खोजना चाहता हूं, मुझे दिनों में अंतर कैसे पता चलेगा?

(दूसरे शब्दों में, मैं CURRENT DATE - yyyy / mm / dd formed date के बीच अंतर खोजना चाहता हूं )

Question 2

नहीं वास्तव में एक विश्वसनीय विधि, JodaTime का उपयोग करने से बेहतर है

  Calendar thatDay = Calendar.getInstance();
  thatDay.set(Calendar.DAY_OF_MONTH,25);
  thatDay.set(Calendar.MONTH,7); // 0-11 so 1 less
  thatDay.set(Calendar.YEAR, 1985);

  Calendar today = Calendar.getInstance();

  long diff = today.getTimeInMillis() - thatDay.getTimeInMillis(); //result in millis

यहां देखें एक अंदाज ...

long days = diff / (24 * 60 * 60 * 1000);

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

  String strThatDay = "1985/08/25";
  SimpleDateFormat formatter = new SimpleDateFormat("yyyy/MM/dd");
  Date d = null;
  try {
   d = formatter.parse(strThatDay);//catch exception
  } catch (ParseException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } 


  Calendar thatDay = Calendar.getInstance();
  thatDay.setTime(d); //rest is the same....

हालाँकि, चूंकि आप तारीख प्रारूप के बारे में निश्चित हैं ... आप Integer.parseInt()अपने संख्यात्मक मूल्यों को प्राप्त करने के लिए यह सबस्ट्रिंग पर भी कर सकते हैं ।

Question 3

यह मेरा काम नहीं है, यहाँ उत्तर मिला । भविष्य में एक टूटी हुई कड़ी नहीं चाहता था :)।

कुंजी इस रेखा को दिन की सेटिंग को ध्यान में रखने के लिए है, पूर्ण कोड को रेफरी करें।

TimeZone.setDefault(TimeZone.getTimeZone("Europe/London"));

या गुजर कोशिश TimeZone करने के लिए एक पैरामीटर के रूप daysBetween()और कॉल setTimeZone()में sDateऔर eDateवस्तुओं।

तो यहाँ यह जाता है:

public static Calendar getDatePart(Date date){
    Calendar cal = Calendar.getInstance();       // get calendar instance
    cal.setTime(date);      
    cal.set(Calendar.HOUR_OF_DAY, 0);            // set hour to midnight
    cal.set(Calendar.MINUTE, 0);                 // set minute in hour
    cal.set(Calendar.SECOND, 0);                 // set second in minute
    cal.set(Calendar.MILLISECOND, 0);            // set millisecond in second
    
    return cal;                                  // return the date part
}

getDatePart () यहां से लिया गया

/**
 * This method also assumes endDate >= startDate
**/
public static long daysBetween(Date startDate, Date endDate) {
  Calendar sDate = getDatePart(startDate);
  Calendar eDate = getDatePart(endDate);

  long daysBetween = 0;
  while (sDate.before(eDate)) {
      sDate.add(Calendar.DAY_OF_MONTH, 1);
      daysBetween++;
  }
  return daysBetween;
}

द Nuances: दो तिथियों के बीच का अंतर खोजना दो तिथियों को घटाकर और (24 * 60 * 60 * 1000) द्वारा परिणाम को विभाजित करने के रूप में सीधा नहीं है। वास्तव में, इसका गलत!

उदाहरण के लिए: दो तारीखों के बीच का अंतर 03/24/2007 और 03/25/2007 1 दिन होना चाहिए; हालाँकि, उपरोक्त विधि का उपयोग करके, यूके में, आपको 0 दिन मिलेंगे!

अपने लिए देखें (नीचे कोड)। मिलीसेकंड के रास्ते जाने से त्रुटियों को दूर किया जा सकता है और वे सबसे स्पष्ट हो जाते हैं जब आपके पास एक छोटी सी चीज होती है जैसे डेलाइट सेविंग टाइम तस्वीर में आती है।

पूर्ण कोड:

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.TimeZone;

public class DateTest {

public class DateTest {

static SimpleDateFormat sdf = new SimpleDateFormat("dd-MMM-yyyy");

public static void main(String[] args) {

  TimeZone.setDefault(TimeZone.getTimeZone("Europe/London"));

  //diff between these 2 dates should be 1
  Date d1 = new Date("01/01/2007 12:00:00");
  Date d2 = new Date("01/02/2007 12:00:00");

  //diff between these 2 dates should be 1
  Date d3 = new Date("03/24/2007 12:00:00");
  Date d4 = new Date("03/25/2007 12:00:00");

  Calendar cal1 = Calendar.getInstance();cal1.setTime(d1);
  Calendar cal2 = Calendar.getInstance();cal2.setTime(d2);
  Calendar cal3 = Calendar.getInstance();cal3.setTime(d3);
  Calendar cal4 = Calendar.getInstance();cal4.setTime(d4);

  printOutput("Manual   ", d1, d2, calculateDays(d1, d2));
  printOutput("Calendar ", d1, d2, daysBetween(cal1, cal2));
  System.out.println("---");
  printOutput("Manual   ", d3, d4, calculateDays(d3, d4));
  printOutput("Calendar ", d3, d4, daysBetween(cal3, cal4));
}


private static void printOutput(String type, Date d1, Date d2, long result) {
  System.out.println(type+ "- Days between: " + sdf.format(d1)
                    + " and " + sdf.format(d2) + " is: " + result);
}

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

/** Using Calendar - THE CORRECT WAY**/
public static long daysBetween(Date startDate, Date endDate) {
  ...
}

OUTPUT:

मैनुअल - दिनों के बीच: 01-Jan-2007 और 02-Jan-2007 है: 1

कैलेंडर - दिनों के बीच: 01-Jan-2007 और 02-Jan-2007 है: 1

मैनुअल - दिनों के बीच: 24-Mar-2007 और 25-Mar-2007 है: 0

कैलेंडर - दिनों के बीच: 24-Mar-2007 और 25-Mar-2007 है: 1

Question 4

अधिकांश उत्तर आपकी समस्या के लिए अच्छे और सही थे

इसलिए मैं दिनों की संख्या के बीच अंतर खोजना चाहता हूं, मुझे दिनों में अंतर कैसे पता चलेगा?

मेरा सुझाव है कि यह बहुत ही सरल और सीधा तरीका है जो आपको किसी भी समय क्षेत्र में सही अंतर देने की गारंटी देता है:

int difference= 
((int)((startDate.getTime()/(24*60*60*1000))
-(int)(endDate.getTime()/(24*60*60*1000))));

और बस!

Question 5

Jodatime API का उपयोग करें

Days.daysBetween(start.toDateMidnight() , end.toDateMidnight() ).getDays()

जहाँ 'आरंभ' और 'अंत' आपकी डेटटाइम ऑब्जेक्ट्स हैं। अपनी तिथि को पार्स करने के लिए डेटाइम ऑब्जेक्ट्स में स्ट्रिंग्स पार्सडेट टाइम पद्धति का उपयोग करते हैं

एक Android विशिष्ट JodaTime पुस्तकालय भी है ।

Question 6

यह टुकड़ा दिन के बचत समय के लिए है और O (1) है।

private final static long MILLISECS_PER_DAY = 24 * 60 * 60 * 1000;

private static long getDateToLong(Date date) {
    return Date.UTC(date.getYear(), date.getMonth(), date.getDate(), 0, 0, 0);
}

public static int getSignedDiffInDays(Date beginDate, Date endDate) {
    long beginMS = getDateToLong(beginDate);
    long endMS = getDateToLong(endDate);
    long diff = (endMS - beginMS) / (MILLISECS_PER_DAY);
    return (int)diff;
}

public static int getUnsignedDiffInDays(Date beginDate, Date endDate) {
    return Math.abs(getSignedDiffInDays(beginDate, endDate));
}

Question 7

यह मेरे लिए सरल और सर्वोत्तम गणना है और आपके लिए हो सकती है।

       try {
            /// String CurrDate=  "10/6/2013";
            /// String PrvvDate=  "10/7/2013";
            Date date1 = null;
            Date date2 = null;
            SimpleDateFormat df = new SimpleDateFormat("M/dd/yyyy");
            date1 = df.parse(CurrDate);
            date2 = df.parse(PrvvDate);
            long diff = Math.abs(date1.getTime() - date2.getTime());
            long diffDays = diff / (24 * 60 * 60 * 1000);


            System.out.println(diffDays);

        } catch (Exception e1) {
            System.out.println("exception " + e1);
        }

Question 8

Correct Wayसैम क्वेस्ट के जवाब से ही अगर पहली तारीख दूसरे से पहले है काम करता है। इसके अलावा, यह 1 वापस आ जाएगा यदि दो तिथियां एक ही दिन के भीतर हों।

यही वह समाधान है जिसने मेरे लिए सबसे अच्छा काम किया। अधिकांश अन्य समाधानों की तरह, यह अभी भी साल में दो दिन गलत परिणाम दिखाएगा क्योंकि गलत दिन प्रकाश बचत ऑफसेट है।

private final static long MILLISECS_PER_DAY = 24 * 60 * 60 * 1000;

long calculateDeltaInDays(Calendar a, Calendar b) {

    // Optional: avoid cloning objects if it is the same day
    if(a.get(Calendar.ERA) == b.get(Calendar.ERA) 
            && a.get(Calendar.YEAR) == b.get(Calendar.YEAR)
            && a.get(Calendar.DAY_OF_YEAR) == b.get(Calendar.DAY_OF_YEAR)) {
        return 0;
    }
    Calendar a2 = (Calendar) a.clone();
    Calendar b2 = (Calendar) b.clone();
    a2.set(Calendar.HOUR_OF_DAY, 0);
    a2.set(Calendar.MINUTE, 0);
    a2.set(Calendar.SECOND, 0);
    a2.set(Calendar.MILLISECOND, 0);
    b2.set(Calendar.HOUR_OF_DAY, 0);
    b2.set(Calendar.MINUTE, 0);
    b2.set(Calendar.SECOND, 0);
    b2.set(Calendar.MILLISECOND, 0);
    long diff = a2.getTimeInMillis() - b2.getTimeInMillis();
    long days = diff / MILLISECS_PER_DAY;
    return Math.abs(days);
}

Question 9

ऐसा करने का सबसे अच्छा और आसान तरीका

  public int getDays(String begin) throws ParseException {
     long MILLIS_PER_DAY = 24 * 60 * 60 * 1000;
     SimpleDateFormat dateFormat = new SimpleDateFormat("dd-MM-yyyy", Locale.ENGLISH);

    long begin = dateFormat.parse(begin).getTime();
    long end = new Date().getTime(); // 2nd date want to compare
    long diff = (end - begin) / (MILLIS_PER_DAY);
    return (int) diff;
}

Question 10

tl; डॉ

ChronoUnit.DAYS.between( 
    LocalDate.parse( "1999-12-28" ) , 
    LocalDate.parse( "12/31/1999" , DateTimeFormatter.ofPattern( "MM/dd/yyyy" ) ) 
)

विवरण

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

java.time

जोडा-टाइम परियोजना उन पुरानी कक्षाओं के प्रतिस्थापन के रूप में अत्यधिक सफल थी। इन कक्षाओं ने जावा 8 और बाद में निर्मित जावा.टाइम ढांचे की प्रेरणा प्रदान की ।

Java.time कार्यक्षमता की ज्यादातर में जावा 6 और 7 के लिए वापस भेजा जाता है ThreeTen-backport और आगे में एंड्रॉयड के लिए अनुकूलित ThreeTenABP ।

`LocalDate`

LocalDateवर्ग समय के दिन और समय क्षेत्र के बिना बिना एक दिनांक-केवल मूल्य का प्रतिनिधित्व करता।

पार्सिंग स्ट्रिंग्स

यदि आपके इनपुट स्ट्रिंग मानक आईएसओ 8601 प्रारूप में हैं, तो LocalDateकक्षा सीधे स्ट्रिंग को पार्स कर सकती है।

LocalDate start = LocalDate.parse( "1999-12-28" );

यदि आईएसओ 8601 प्रारूप में नहीं है, तो एक प्रारूपण पैटर्न को परिभाषित करें DateTimeFormatter।

String input = "12/31/1999";
DateTimeFormatter formatter = DateTimeFormatter.ofPattern( "MM/dd/yyyy" );
LocalDate stop = LocalDate.parse( input , formatter );

बीता हुआ दिन `ChronoUnit`

अब LocalDateवस्तुओं की उस जोड़ी के बीच बीते हुए दिनों की गिनती प्राप्त करें । ChronoUnitEnum गणना समय बीत।

long totalDays = ChronoUnit.DAYS.between( start , stop ) ;

यदि आप जावा एनम से अपरिचित हैं, तो जान लें कि वे अधिक शक्तिशाली और उपयोगी हैं जो अधिकांश अन्य प्रोग्रामिंग भाषाओं में पारंपरिक एनम हैं। अधिक जानने के लिए Enumक्लास डॉक, ओरेकल ट्यूटोरियल और विकिपीडिया देखें ।

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

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

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

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

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

जावा एसई 8 और एसई 9 और बाद में
- निर्मित।
- बंडल के कार्यान्वयन के साथ मानक जावा एपीआई का एक हिस्सा।
- जावा 9 में कुछ छोटी विशेषताएं और सुधार शामिल हैं।
जावा एसई 6 और एसई 7
- जावा-टाइम की अधिकांश कार्यक्षमता थ्रीटेन-बैकपोर्ट में जावा 6 और 7 में वापस रखी गई है ।
एंड्रॉयड
- ThreeTenABP परियोजना adapts ThreeTen-backport विशेष रूप से Android के लिए (जैसा कि ऊपर उल्लेख)।
- देखें कि थ्रीटेनब का उपयोग कैसे करें… ।

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

Question 11

निम्नलिखित कार्यों का उपयोग करें:

   /**
     * Returns the number of days between two dates. The time part of the
     * days is ignored in this calculation, so 2007-01-01 13:00 and 2007-01-02 05:00
     * have one day inbetween.
     */
    public static long daysBetween(Date firstDate, Date secondDate) {
        // We only use the date part of the given dates
        long firstSeconds = truncateToDate(firstDate).getTime()/1000;
        long secondSeconds = truncateToDate(secondDate).getTime()/1000;
        // Just taking the difference of the millis.
        // These will not be exactly multiples of 24*60*60, since there
        // might be daylight saving time somewhere inbetween. However, we can
        // say that by adding a half day and rounding down afterwards, we always
        // get the full days.
        long difference = secondSeconds-firstSeconds;
        // Adding half a day
        if( difference >= 0 ) {
            difference += SECONDS_PER_DAY/2; // plus half a day in seconds
        } else {
            difference -= SECONDS_PER_DAY/2; // minus half a day in seconds
        }
        // Rounding down to days
        difference /= SECONDS_PER_DAY;

        return difference;
    }

    /**
     * Truncates a date to the date part alone.
     */
    @SuppressWarnings("deprecation")
    public static Date truncateToDate(Date d) {
        if( d instanceof java.sql.Date ) {
            return d; // java.sql.Date is already truncated to date. And raises an
                      // Exception if we try to set hours, minutes or seconds.
        }
        d = (Date)d.clone();
        d.setHours(0);
        d.setMinutes(0);
        d.setSeconds(0);
        d.setTime(((d.getTime()/1000)*1000));
        return d;
    }

Question 12

एक सरल समाधान है, कि कम से कम मेरे लिए, एकमात्र संभव समाधान है।

समस्या यह है कि मेरे द्वारा देखे गए सभी उत्तर - जोडा, या कैलेंडर, या दिनांक का उपयोग करके, या जो कुछ भी - केवल मिलीसेकंड की मात्रा को ध्यान में रखते हैं। वे दिनों की वास्तविक संख्या के बजाय दो तिथियों के बीच 24 घंटे के चक्रों की संख्या की गिनती करते हैं । तो 1 जनवरी को दोपहर 11 बजे से जन 2 1 बजे कुछ दिन 0 लौटेंगे।

startDateऔर के बीच दिनों की वास्तविक संख्या की गणना करने के लिए endDate, बस:

// Find the sequential day from a date, essentially resetting time to start of the day
long startDay = startDate.getTime() / 1000 / 60 / 60 / 24;
long endDay = endDate.getTime() / 1000 / 60 / 60 / 24;

// Find the difference, duh
long daysBetween = endDay - startDay;

यह जन 2 और 1 जनवरी के बीच "1" वापस आ जाएगा। यदि आपको अंतिम दिन की गणना करने की आवश्यकता है, तो बस 1 को जोड़ें daysBetween(मुझे अपने कोड में ऐसा करने की आवश्यकता थी क्योंकि मैं रेंज में कुल दिनों की संख्या गिनना चाहता था)।

यह कुछ हद तक डैनियल द्वारा सुझाए गए लेकिन छोटे कोड के समान है जो मुझे लगता है।

Question 13

ये सभी समाधान दो समस्याओं में से एक से पीड़ित हैं। राउंडिंग एरर, लीप डेज और सेकंड्स, आदि के कारण या तो समाधान पूरी तरह से सटीक नहीं है या आप अपनी दो अज्ञात तारीखों के बीच दिनों की संख्या पर लूपिंग समाप्त कर देते हैं।

यह समाधान पहली समस्या को हल करता है, और लगभग 365 के एक कारक द्वारा दूसरे में सुधार करता है, बेहतर है यदि आप जानते हैं कि आपकी अधिकतम सीमा क्या है।

/**
 * @param thisDate
 * @param thatDate
 * @param maxDays
 *            set to -1 to not set a max
 * @returns number of days covered between thisDate and thatDate, inclusive, i.e., counting both
 *          thisDate and thatDate as an entire day. Will short out if the number of days exceeds
 *          or meets maxDays
 */
public static int daysCoveredByDates(Date thisDate, Date thatDate, int maxDays) {
    //Check inputs
    if (thisDate == null || thatDate == null) {
        return -1;
    }

    //Set calendar objects
    Calendar startCal = Calendar.getInstance();
    Calendar endCal = Calendar.getInstance();
    if (thisDate.before(thatDate)) {
        startCal.setTime(thisDate);
        endCal.setTime(thatDate);
    }
    else {
        startCal.setTime(thatDate);
        endCal.setTime(thisDate);
    }

    //Get years and dates of our times.
    int startYear = startCal.get(Calendar.YEAR);
    int endYear = endCal.get(Calendar.YEAR);
    int startDay = startCal.get(Calendar.DAY_OF_YEAR);
    int endDay = endCal.get(Calendar.DAY_OF_YEAR);

    //Calculate the number of days between dates.  Add up each year going by until we catch up to endDate.
    while (startYear < endYear && maxDays >= 0 && endDay - startDay + 1 < maxDays) {
        endDay += startCal.getActualMaximum(Calendar.DAY_OF_YEAR); //adds the number of days in the year startDate is currently in
        ++startYear;
        startCal.set(Calendar.YEAR, startYear); //reup the year
    }
    int days = endDay - startDay + 1;

    //Honor the maximum, if set
    if (maxDays >= 0) {
        days = Math.min(days, maxDays);
    }
    return days;
}

यदि आपको तिथियों के बीच के दिनों की आवश्यकता होती है (बाद की तारीख के विशिष्ट), तो बस + 1जब आप देखते हैं तो छुटकारा पाएं endDay - startDay + 1।

Question 14

एक और तरीका:

public static int numberOfDaysBetweenDates(Calendar fromDay, Calendar toDay) {
        fromDay = calendarStartOfDay(fromDay);
        toDay = calendarStartOfDay(toDay);
        long from = fromDay.getTimeInMillis();
        long to = toDay.getTimeInMillis();
        return (int) TimeUnit.MILLISECONDS.toDays(to - from);
    }

Question 15

इन कार्यों का उपयोग करें

    public static int getDateDifference(int previousYear, int previousMonthOfYear, int previousDayOfMonth, int nextYear, int nextMonthOfYear, int nextDayOfMonth, int differenceToCount){
    // int differenceToCount = can be any of the following
    //  Calendar.MILLISECOND;
    //  Calendar.SECOND;
    //  Calendar.MINUTE;
    //  Calendar.HOUR;
    //  Calendar.DAY_OF_MONTH;
    //  Calendar.MONTH;
    //  Calendar.YEAR;
    //  Calendar.----

    Calendar previousDate = Calendar.getInstance();
    previousDate.set(Calendar.DAY_OF_MONTH, previousDayOfMonth);
    // month is zero indexed so month should be minus 1
    previousDate.set(Calendar.MONTH, previousMonthOfYear);
    previousDate.set(Calendar.YEAR, previousYear);

    Calendar nextDate = Calendar.getInstance();
    nextDate.set(Calendar.DAY_OF_MONTH, previousDayOfMonth);
    // month is zero indexed so month should be minus 1
    nextDate.set(Calendar.MONTH, previousMonthOfYear);
    nextDate.set(Calendar.YEAR, previousYear);

    return getDateDifference(previousDate,nextDate,differenceToCount);
}
public static int getDateDifference(Calendar previousDate,Calendar nextDate,int differenceToCount){
    // int differenceToCount = can be any of the following
    //  Calendar.MILLISECOND;
    //  Calendar.SECOND;
    //  Calendar.MINUTE;
    //  Calendar.HOUR;
    //  Calendar.DAY_OF_MONTH;
    //  Calendar.MONTH;
    //  Calendar.YEAR;
    //  Calendar.----

    //raise an exception if previous is greater than nextdate.
    if(previousDate.compareTo(nextDate)>0){
        throw new RuntimeException("Previous Date is later than Nextdate");
    }

    int difference=0;
    while(previousDate.compareTo(nextDate)<=0){
        difference++;
        previousDate.add(differenceToCount,1);
    }
    return difference;
}

Question 16

        public void dateDifferenceExample() {

        // Set the date for both of the calendar instance
        GregorianCalendar calDate = new GregorianCalendar(2012, 10, 02,5,23,43);
        GregorianCalendar cal2 = new GregorianCalendar(2015, 04, 02);

        // Get the represented date in milliseconds
        long millis1 = calDate.getTimeInMillis();
        long millis2 = cal2.getTimeInMillis();

        // Calculate difference in milliseconds
        long diff = millis2 - millis1;

        // Calculate difference in seconds
        long diffSeconds = diff / 1000;

        // Calculate difference in minutes
        long diffMinutes = diff / (60 * 1000);

        // Calculate difference in hours
        long diffHours = diff / (60 * 60 * 1000);

        // Calculate difference in days
        long diffDays = diff / (24 * 60 * 60 * 1000);
    Toast.makeText(getContext(), ""+diffSeconds, Toast.LENGTH_SHORT).show();


}

Question 17

मुझे यह करने का एक बहुत आसान तरीका मिला और यह वह है जो मैं अपने ऐप में उपयोग कर रहा हूं।

मान लीजिए कि आपके पास समय की वस्तुओं में तारीखें हैं (या जो भी हो, हमें बस मिलीसेकंड चाहिए):

Time date1 = initializeDate1(); //get the date from somewhere
Time date2 = initializeDate2(); //get the date from somewhere

long millis1 = date1.toMillis(true);
long millis2 = date2.toMillis(true);

long difference = millis2 - millis1 ;

//now get the days from the difference and that's it
long days = TimeUnit.MILLISECONDS.toDays(difference);

//now you can do something like
if(days == 7)
{
    //do whatever when there's a week of difference
}

if(days >= 30)
{
    //do whatever when it's been a month or more
}

Question 18

Joda समय

सबसे अच्छा तरीका है कि आप अपने प्रोजेक्ट में जोडा-टाइम बेहद सफल ओपन-सोर्स लाइब्रेरी का इस्तेमाल करें।

String date1 = "2015-11-11";
String date2 = "2013-11-11";
DateTimeFormatter formatter = new DateTimeFormat.forPattern("yyyy-MM-dd");
DateTime d1 = formatter.parseDateTime(date1);
DateTime d2 = formatter.parseDateTime(date2);
long diffInMillis = d2.getMillis() - d1.getMillis();

Duration duration = new Duration(d1, d2);
int days = duration.getStandardDays();
int hours = duration.getStandardHours();
int minutes = duration.getStandardMinutes();

यदि आप Android Studio का उपयोग कर रहे हैं , तो joda-time जोड़ना बहुत आसान है। अपने build.gradle (ऐप) में:

dependencies {
  compile 'joda-time:joda-time:2.4'
  compile 'joda-time:joda-time:2.4'
  compile 'joda-time:joda-time:2.2'
}

Question 19

        Date userDob = new SimpleDateFormat("yyyy-MM-dd").parse(dob);
        Date today = new Date();
        long diff =  today.getTime() - userDob.getTime();
        int numOfDays = (int) (diff / (1000 * 60 * 60 * 24));
        int hours = (int) (diff / (1000 * 60 * 60));
        int minutes = (int) (diff / (1000 * 60));
        int seconds = (int) (diff / (1000));