Ich erhalte das aktuelle Datum (im Format 31.12.1999, dh MM / TT / JJJJ) unter Verwendung des folgenden Codes:

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

und ich habe ein anderes Datum im Format: 2010-08-25 (dh JJJJ / MM / TT),

Ich möchte also den Unterschied zwischen dem Datum in der Anzahl der Tage ermitteln. Wie finde ich den Unterschied in Tagen?

(Mit anderen Worten, ich möchte den Unterschied zwischen AKTUELLEM DATUM - JJJJ / MM / TT formatiertes Datum herausfinden. )

Keine wirklich zuverlässige Methode, besser als 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

Hier ist eine Annäherung ...

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

Um das Datum aus einer Zeichenfolge zu analysieren, können Sie verwenden

  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....

Da Sie sich des Datumsformats sicher sind, können Sie auch Integer.parseInt()die Teilzeichenfolgen verwenden, um deren numerische Werte zu erhalten.

Dies ist NICHT meine Arbeit, fand die Antwort hier . wollte in Zukunft keinen defekten Link :).

Der Schlüssel ist diese Zeile zur Berücksichtigung der Tageslichteinstellung, siehe Vollständiger Code.

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

oder versuchen Sie, TimeZone als Parameter an die Objekte und zu übergeben daysBetween()und diese aufzurufen .setTimeZone()sDateeDate

Also los geht's:

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 () von hier genommen

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

Die Nuancen: Das Finden des Unterschieds zwischen zwei Daten ist nicht so einfach wie das Subtrahieren der beiden Daten und das Teilen des Ergebnisses durch (24 * 60 * 60 * 1000). Tatsächlich ist es falsch!

Zum Beispiel: Die Differenz zwischen den beiden Daten 24.03.2007 und 25.03.2007 sollte 1 Tag betragen. Mit der oben genannten Methode erhalten Sie in Großbritannien jedoch 0 Tage!

Überzeugen Sie sich selbst (Code unten). Wenn Sie den Millisekunden-Weg gehen, werden Fehler abgerundet, und diese werden am deutlichsten, wenn Sie etwas wie Sommerzeit ins Bild setzen.

Vollständiger Code:

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) {
  ...
}

AUSGABE:

Handbuch - Tage zwischen: 01-Jan-2007 und 02-Jan-2007 ist: 1

Kalender - Die Tage zwischen dem 01.01.2007 und dem 02.01.2007 sind: 1

---

Handbuch - Die Tage zwischen dem 24. März 2007 und dem 25. März 2007 sind: 0

Kalender - Die Tage zwischen dem 24. März 2007 und dem 25. März 2007 sind: 1

Die meisten Antworten waren gut und richtig für Ihr Problem von

Ich möchte also den Unterschied zwischen dem Datum in der Anzahl der Tage ermitteln. Wie finde ich den Unterschied in Tagen?

Ich schlage diesen sehr einfachen und unkomplizierten Ansatz vor, der Ihnen garantiert den richtigen Unterschied in jeder Zeitzone bietet:

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

Und das ist es!

Verwenden Sie die Jodatime-API

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

Dabei sind 'Start' und 'Ende' Ihre DateTime- Objekte. Verwenden Sie die parseDateTime-Methode, um Ihre Datumszeichenfolgen in DateTime-Objekte zu analysieren

Es gibt auch eine androidspezifische JodaTime-Bibliothek .

Dieses Fragment berücksichtigt die Sommerzeit und ist 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));
}

Dies ist eine einfache und beste Berechnung für mich und kann für Sie sein.

       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);
        }

Die Correct WayAntwort von Sam Quest funktioniert nur, wenn das erste Datum vor dem zweiten liegt. Darüber hinaus wird 1 zurückgegeben, wenn die beiden Daten innerhalb eines Tages liegen.

Dies ist die Lösung, die für mich am besten funktioniert hat. Wie bei den meisten anderen Lösungen werden an zwei Tagen im Jahr aufgrund des falschen Tageslichtversatzes immer noch falsche Ergebnisse angezeigt.

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);
}

beste und einfachste Möglichkeit, dies zu tun

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

tl; dr

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

Einzelheiten

Andere Antworten sind veraltet. Die alten Datums- und Uhrzeitklassen, die mit den frühesten Versionen von Java gebündelt wurden, haben sich als schlecht gestaltet, verwirrend und problematisch erwiesen. Vermeide sie.

java.time

Das Joda-Time-Projekt war als Ersatz für diese alten Klassen sehr erfolgreich. Diese Klassen lieferten die Inspiration für das in Java 8 und höher integrierte java.time- Framework.

Ein Großteil der Funktionen von java.time wird in ThreeTen-Backport auf Java 6 & 7 zurückportiert und in ThreeTenABP weiter an Android angepasst .

LocalDate

Die LocalDateKlasse repräsentiert einen Nur-Datum-Wert ohne Tageszeit und ohne Zeitzone.

Strings analysieren

Wenn Ihre Eingabezeichenfolgen im Standardformat ISO 8601 vorliegen, kann die LocalDateKlasse die Zeichenfolge direkt analysieren.

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

Wenn nicht im ISO 8601-Format, definieren Sie ein Formatierungsmuster mit DateTimeFormatter.

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

Verstrichene Tage über ChronoUnit

Ermitteln Sie nun die Anzahl der Tage, die zwischen diesem Objektpaar vergangen LocalDatesind. Die ChronoUnitAufzählung berechnet die verstrichene Zeit.

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

Wenn Sie mit Java-Enums nicht vertraut sind, wissen Sie, dass sie weitaus leistungsfähiger und nützlicher sind als herkömmliche Enums in den meisten anderen Programmiersprachen. Weitere EnumInformationen finden Sie im Klassendokument, im Oracle-Lernprogramm und in Wikipedia .

Über java.time

Das java.time- Framework ist in Java 8 und höher integriert. Diese Klassen verdrängen die lästigen alten Legacy - Datum-Zeit - Klassen wie java.util.Date, Calendar, & SimpleDateFormat.

Das Joda-Time- Projekt, das sich jetzt im Wartungsmodus befindet , empfiehlt die Migration zu den Klassen java.time .

Weitere Informationen finden Sie im Oracle-Lernprogramm . Suchen Sie im Stapelüberlauf nach vielen Beispielen und Erklärungen. Die Spezifikation ist JSR 310 .

Woher bekomme ich die java.time-Klassen?

• Java SE 8 und SE 9 und höher
  • Eingebaut.
  • Teil der Standard-Java-API mit einer gebündelten Implementierung.
  • Java 9 fügt einige kleinere Funktionen und Korrekturen hinzu.
• Java SE 6 und SE 7
  • Ein Großteil der Funktionen von java.time wird in ThreeTen-Backport auf Java 6 & 7 zurückportiert .
• Android
  • Das ThreeTenABP- Projekt passt ThreeTen-Backport (oben erwähnt) speziell für Android an.
  • Siehe Verwendung von ThreeTenABP… .

Das ThreeTen-Extra- Projekt erweitert java.time um zusätzliche Klassen. Dieses Projekt ist ein Testfeld für mögliche zukünftige Ergänzungen von java.time. Sie können einige nützliche Klassen hier wie finden Interval, YearWeek, YearQuarter, und mehr .

Verwenden Sie die folgenden Funktionen:

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

Es gibt eine einfache Lösung, die zumindest für mich die einzig mögliche ist.

Das Problem ist, dass alle Antworten, die ich sehe - mit Joda, Kalender, Datum oder was auch immer - nur die Anzahl der Millisekunden berücksichtigen. Am Ende zählen sie die Anzahl der 24-Stunden-Zyklen zwischen zwei Daten und nicht die tatsächliche Anzahl der Tage . Also wird etwas vom 1. Januar 23 Uhr bis 2. Januar 1 Uhr 0 Tage zurückgeben.

Um die tatsächliche Anzahl der Tage zwischen startDateund zu zählen endDate, gehen Sie einfach wie folgt vor:

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

Dies wird zwischen dem 2. und 1. Januar "1" zurückgeben. Wenn Sie den Endtag zählen müssen, fügen Sie einfach 1 hinzu daysBetween(das musste ich in meinem Code tun, da ich die Gesamtzahl der Tage im Bereich zählen wollte).

Dies ist etwas ähnlich zu dem, was Daniel vorgeschlagen hat, aber ich nehme an , kleinerer Code.

Alle diese Lösungen leiden unter einem von zwei Problemen. Entweder ist die Lösung aufgrund von Rundungsfehlern, Schalttagen und Sekunden usw. nicht genau, oder Sie durchlaufen die Anzahl der Tage zwischen Ihren beiden unbekannten Daten.

Diese Lösung löst das erste Problem und verbessert das zweite um den Faktor 365, besser, wenn Sie wissen, wie hoch Ihre maximale Reichweite ist.

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

Wenn Sie Tage zwischen Daten benötigen (ohne das letztere Datum einzuschließen), entfernen Sie diese einfach, + 1wenn Sie sie sehen endDay - startDay + 1.

Ein anderer Weg:

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);
    }

Verwenden Sie diese Funktionen

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

        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();


}

Ich habe einen sehr einfachen Weg gefunden, dies zu tun, und es ist das, was ich in meiner App verwende.

Angenommen, Sie haben die Daten in Zeitobjekten (oder was auch immer, wir brauchen nur die Millisekunden):

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
}

Joda-Zeit

Am besten verwenden Sie Joda-Time , die äußerst erfolgreiche Open-Source-Bibliothek, die Sie Ihrem Projekt hinzufügen würden.

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();

Wenn Sie Android Studio verwenden , ist es sehr einfach, Joda-Zeit hinzuzufügen. In Ihrem build.gradle (App):

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

        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));