Ce n'est PAS mon travail, a trouvé la réponse ici. je ne voulais pas un lien cassé à l'avenir :).

La clé est cette ligne pour prendre en compte le réglage de la lumière du jour, ref Code complet.

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

Ou essayez de passer TimeZone en tant que paramètre à daysBetween() et appelez setTimeZone() dans les objets sDate et eDate.

Alors voilà:

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() extrait deici

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

Les nuances: Trouver la différence entre deux dates n'est pas aussi simple que de soustraire les deux dates et de diviser le résultat par (24 * 60 * 60 * 1000). En effet, son erronées!

Par exemple: {[19] } La différence entre les deux dates 24/03/2007 et 25/03/2007 devrait être de 1 jour; Cependant, en utilisant la méthode ci-dessus, au Royaume-Uni, vous obtiendrez 0 jours!

Voyez par vous-même (code ci-dessous). Aller de la manière millisecondes conduira à arrondir les erreurs et ils deviennent plus évidents une fois que vous avez une petite chose comme l'heure d'été venir dans l'image.

Code Complet:

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

SORTIE:

Manuel-Jours entre: 01-Jan-2007 et 02-Jan-2007 est: 1

Calendrier de Jours entre le: 01-Jan-2007 et 02-Jan-2007 est la suivante: 1

---

Manuel-Jours entre: 24-Mar-2007 et 25-Mar-2007 est: 0

Calendrier de Jours entre le: 24-Mar-2007 et 25-Mar-2007 est la suivante: 1

La plupart des réponses étaient bonnes et correctes pour votre problème de

, Donc je veux savoir la différence entre la date en nombre de jours, comment puis-je trouver la différence en jours?

Je suggère cette approche très simple et directe qui est garantie pour vous donner la différence correcte dans n'importe quel fuseau horaire:

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

Et c'est tout!

Vous pouvez utiliser l'API jodatime

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

Où 'start' et 'end' sont vos objets DateTime . Pour analyser vos chaînes de date dans des objets DateTime, utilisez la méthode parseDateTime

Il existe également une bibliothèque JodaTime spécifique à Android.

Ce fragment représente l'heure d'été et est 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));
}

C'est un calcul simple et le meilleur pour moi et peut-être pour vous.

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

Le Correct Way de la réponse de Sam Quest ne fonctionne que si la première date est antérieure à la seconde. De plus, il retournera 1 si les deux dates sont dans un seul jour.

C'est la solution qui a le mieux fonctionné pour moi. Tout comme la plupart des autres solutions, il afficherait toujours des résultats incorrects sur deux jours dans une année en raison d'un décalage d'économie de lumière du jour incorrect.

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

La meilleure et la plus simple façon de le faire

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

Utilisez les fonctions suivantes:

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

Il y a une solution simple, qui au moins pour moi, est la seule solution réalisable.

Le problème est que toutes les réponses que je vois être ballottées - en utilisant Joda, ou Calendar, ou Date, ou autre - ne prennent en compte que la quantité de millisecondes. Ils finissent par compter le numéro de 24 heures de cycles entre deux dates plutôt que , le nombre réel de jours. Donc, quelque chose de Jan 1st 11pm à Jan 2nd 1am reviendra 0 jours.

Pour compter le nombre réel de jours entre startDate et endDate, faites simplement:

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

Cela retournera "1" entre le 2 janvier et le 1er janvier. Si vous devez compter le jour de fin, ajoutez simplement 1 à daysBetween (je devais le faire dans mon code car je voulais compter le nombre total de jours dans la plage).

Ceci est quelque peu similaire à ce que Daniel a suggéré mais un code plus petit, je suppose.

Toutes ces solutions souffrent de l'un des deux problèmes. Soit la solution n'est pas parfaitement précise en raison d'erreurs d'arrondi, de jours et de secondes bissextiles, etc. ou vous finissez par boucler le nombre de jours entre vos deux dates inconnues.

Cette solution résout le premier problème et améliore le second d'un facteur d'environ 365, mieux si vous savez quelle est votre plage maximale.

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

Si vous avez besoin de jours entre les dates (non inclus de cette dernière date), débarrassez-vous simplement du + 1 quand vous voyez endDay - startDay + 1.

Tl; dr

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

Détails

Les autres réponses sont obsolètes. Les anciennes classes date-heure fournies avec les premières versions de Java se sont avérées mal conçues, déroutantes et gênantes. Les éviter.

Java.temps

Le projet Joda-Time a connu un grand succès en remplacement de ces anciennes classes. Ces classes ont fourni l'inspiration pour le java.time framework intégré dans Java 8 et versions ultérieures.

Une grande partie du java.temps la fonctionnalité est rétroportée vers Java 6 et 7 dans ThreeTen-Backport et adaptée à Android dans ThreeTenABP .

LocalDate

Le LocalDate la classe représente une valeur de date uniquement sans heure et sans fuseau horaire.

Analyse des chaînes

Si vos chaînes d'entrée sont au format standard ISO 8601, la classe LocalDate peut directement analyser la chaîne.

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

Si ce n'est pas au format ISO 8601, définissez un modèle de formatage avec DateTimeFormatter.

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

Jours Écoulés via ChronoUnit

Obtenez maintenant le nombre de jours écoulés entre cette paire d'objets LocalDate. L'ChronoUnit enum calcule le temps écoulé.

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

Si vous n'êtes pas familier avec les énumérations Java, sachez qu'elles sont beaucoup plus puissantes et utiles que les énumérations conventionnelles dans la plupart des autres langages de programmation. Voir le Enum il s'agit d'un document de classe, le Tutoriel Oracle, et Wikipedia pour en savoir plus.

À propos Java.temps

Le java.time framework est intégré à Java 8 et versions ultérieures. Ces classes permettent d'éviter la pénible vieux héritage date-heure classes telles que java.util.Date, Calendar, & SimpleDateFormat.

Le projet Joda-Time, maintenant en mode maintenance, conseille la migration vers le java.temps classes.

Pour en savoir plus, consultez le tutoriel Oracle. Et rechercher Stack Overflow pour de nombreux exemples et explication. La spécification est JSR 310.

Où obtenir le java.les classes de temps?

• Java SE 8 et SE 9 et plus tard
  • Intégré.
  • Partie de l'API Java standard avec une implémentation groupée.
  • Java 9 ajoute quelques fonctionnalités et corrections mineures.
• Java SE 6 et SE 7
  • Une grande partie du java.temps la fonctionnalité est porté à Java 6 et 7ThreeTen-Backport.
• Android
  • Le Troisabp le projet adapte ThreeTen-Backport (mentionné ci-dessus) pour Android spécifiquement.
  • Voir Comment utiliser ThreeTenABP....

Le projet ThreeTen-Extra étend java.temps avec classes supplémentaires. Ce projet est un terrain d'essai pour d'éventuels ajouts futurs à java.temps. Vous pouvez trouver quelques classes utiles ici comme Interval, YearWeek, YearQuarter, et plus.

Une autre façon:

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

, j'ai trouvé un moyen très facile à faire, et c'est ce que j'utilise dans mon application.

Disons que vous avez les dates dans les objets Time (ou quoi que ce soit, nous avons juste besoin des millisecondes):

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

Le meilleur moyen est d'utiliser Joda-Time, la bibliothèque open source très réussie que vous ajouteriez à votre projet.

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

Si vous utilisez Android Studio, très facile d'ajouter de joda-time. Dans votre construction.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));

Utilisez ces fonctions

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