Android / Java - Datumsunterschied in Tagen

80

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

Paresh Mayani
quelle
Dieser Code verwendet problematische alte Datums- / Uhrzeitklassen, die jetzt durch die Klassen java.time ersetzt werden. Informationen zu älteren Java- und Android -Geräten finden Sie in den Projekten ThreeTen-Backport und ThreeTenABP .
Basil Bourque
Ähnliche Frage, aber mit Momenten statt ganzen Daten: Datumsunterschied in Tagen, in Android
Basil Bourque

Antworten:

126

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.

st0le
quelle
@stOle Danke, aber ich habe beide das Datum in Strings, also wie mache ich das, bitte lassen Sie mich im Detail wissen, pls
Paresh Mayani
1
@stOle nicht die genaue Antwort bekommen, kann ein kleiner Fehler in Ihrem Code sein, ich bekomme 274 Tage Lücke, auch wenn ich String strThatDay = "2010/10/03" gesetzt habe;, es sollte nur 1 Tag sein, danke für den Support
Paresh Mayani
@Paresh, es tut mir so leid, das ("yyyy/mm/dd");sollte durch ("yyyy/MM/dd");It's Capital M für Monat, Kleinbuchstaben für Minuten ersetzt werden. Korrigiert.
st0le
1
@Gevorg, ich habe es empfohlen. :) Me Gusta JodaTime
st0le
3
Manchmal hat dieser Code aufgrund von Rundungsproblemen (deren Fehlen) beim Teilen der Millisekunden einen freien Tag. Das funktioniert bei mir:Math.round(millisBetweenDates * 1f / TimeUnit.MILLISECONDS.convert(1, TimeUnit.DAYS));
Ciske Boekelo
82

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

Samuel
quelle
Zustimmen. Verwenden von Methoden der obersten Ebene Sie erhalten zuverlässigere und elegantere Lösungen. Vielen Dank!
Roger Alien
Für die Methode: TageZwischen zwischen dem Datum 15:00 Uhr am 24. Juli 2012 und dem Enddatum 16:00 Uhr am 24. Juli 2012 - dann liegt das Datum vor dem Enddatum, jedoch nicht um einen ganzen Tag, sondern nur um eine Stunde. Fehlt mir etwas oder wäre das Ergebnis von daysBetween in diesem Fall falsch (da das erwartete Ergebnis Null ist, aber bei der angegebenen Berechnung eher 1 als Null ergeben sollte)?
AgentKnopf
@ Zainodis, über den Kopf, habe ich den Code aktualisiert. Ich denke, dies sollte das Problem lösen.
Samuel
@ SamQuest Danke für die Aktualisierung! Ich habe einen naiveren Ansatz gewählt: Die while-Schleife mit sDate.before (eDate) wird gestoppt und das Ergebnis zurückgegeben, wenn Start und Ende am selben Tag, Monat und Jahr liegen. Dies stellt auch sicher, dass, wenn Start und Ende in der ersten Iteration am selben Tag / Monat / Jahr liegen (obwohl der zeitliche Start vor dem Ende liegt), Null korrekt zurückgegeben wird.
AgentKnopf
Sie, Sir, verdienen eine Glocke!
Marienke
38

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!

Lisa Anne
quelle
Auch das hat bei mir funktioniert. Andere waren viel zu komplex und viel zu genau :)
Siddharth
1
Wäre besser, wenn Sie zuerst subtrahieren und später teilen, um ein zweimaliges Teilen zu verhindern.
Ravindu1024
@ ravindu1024 Dies ergibt einen Unterschied von +1, wenn das Startdatum kleiner als das Enddatum ist. In diesem Fall gibt es einen Unterschied von +1. Könnte durch Hinzufügen von -1 zur Antwort gelöst werden.
SHOLE
@ SHOLE wie? Was ich sage ist, dass Sie (t1-t2) / C anstelle von t1 / C - t2 / C tun sollten. Da weder t1 / C noch t2 / C Null sein werden, kann ich nicht sehen, wie sich dies auf die Antwort auswirken würde.
Ravindu1024
@ ravindu1024 Ich habe verstanden, was Sie sagen wollen, und habe mich das gleiche gefragt, als ich diese Antwort gelesen habe. Erst nach der Implementierung bemerkte ich, warum es nicht so gemacht wurde (der Grund, den ich oben erwähnte).
SHOLE
25

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 .

Jeroen Rosenberg
quelle
3
Vielen Dank für die Unterstützung, aber nicht glücklich, andere API zu verwenden, wenn es mit dem Android / JAVA-Code gemacht wird
Paresh Mayani
2
+1 für Joda. Die Java-Kalender-API ist ein schreckliches Durcheinander und Joda ist sauber und schön.
LuxuryMode
JodaTime gibt mehrere Fehler mit mehreren Geräten in Android, ich weiß nicht warum, ich habe mehrere Probleme damit
Josemwarrior
1
Die Joda-Zeitbibliothek fügt Ihrem Projekt 4744 Methoden hinzu. Wählen Sie mit Bedacht aus, wenn Sie das 65K-Methodenlimit vermeiden möchten.
Lior Iluz
14

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));
}
Markshiz
quelle
6

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);
        }
Rishi Gautam
quelle
@PareshMayani gerade einchecken log cat
Rishi Gautam
3

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);
}
ccpizza
quelle
3

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;
}
Sumit
quelle
3

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?

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 .

Basil Bourque
quelle
java.time.LocalDate wird in Android nicht unterstützt
Mahdi Astanei
1
@ MahdiAstanei Lesen Sie noch einmal meinen dritten Absatz über die ThreeTenABP- Bibliothek für Android. Es lohnt sich, Ihre App zu erweitern, da die alten Datums- und Uhrzeitklassen wirklich so schlecht sind.
Basil Bourque
2

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;
    }
Daniel
quelle
2

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.

zeh
quelle
2

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.

Drdaanger
quelle
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);
    }
anil
quelle
Bitte geben Sie einen Kommentar zu dem von Ihnen angegebenen Code ab. Die Leute verstehen also die Bedeutung Ihres Codes.
Abed Putra
1

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;
}
Neal Zedlav
quelle
Dieser Code verwendet problematische alte Datums- / Uhrzeitklassen, die jetzt durch die Klassen java.time ersetzt werden. Informationen zu älteren Java- und Android -Geräten finden Sie in den Projekten ThreeTen-Backport und ThreeTenABP .
Basil Bourque
Ist die Kalenderklasse eine alte Datums- / Uhrzeitklasse?
Neal Zedlav
Ja, jede datums- / zeitbezogene Klasse, die außerhalb des java.timePakets gefunden wird, ist jetzt Legacy und sollte vermieden werden. Dies umfasst die Klassen Dateund Calendarund java.sql. Siehe das Oracle-Tutorial.
Basil Bourque
1
        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();


}
Syed Danish Haider
quelle
0

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
}
Gonan
quelle
0

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'
}
Kristy Welsh
quelle
Gute Antwort. Beachten Sie, dass Aufruf toStringauf Durationerzeugt eine String - Darstellung in einem der ISO 8601 Standard - Formate PnYnMnDTnHnMnS . Das Pmarkiert den Anfang, während das TJahr-Monat-Tag von der Stunde-Minute-Sekunde trennt. So P3Dist drei Tage und P3DT12Hist dreieinhalb Tage.
Basil Bourque
2
Die Joda-Zeitbibliothek fügt Ihrem Projekt 4744 Methoden hinzu. Wählen Sie mit Bedacht aus, wenn Sie das 65K-Methodenlimit vermeiden möchten.
Lior Iluz
Dies muss in DateTimeFormatter formatter = DateTimeFormat.forPattern ("JJJJ-MM-
TT
0
        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));
Nilesh Savaliya
quelle