Java, calcule le nombre de jours entre deux dates
Duplicate possible:
Calcul de la différence entre deux Java Date Instances
En Java, je veux calculer le nombre de jours entre deux dates.
Dans ma base de données, ils sont stockés en tant que type de données DATE, mais dans mon code, ils sont des chaînes.
Je veux calculer le nombre de jours entre ces deux chaînes.
Pour commencer, vous devriez seulement les traiter comme des chaînes lorsque vous devez le faire. La plupart du temps, vous devriez travailler avec eux dans un type de données qui décrit réellement les données avec lesquelles vous travaillez.
Je vous recommande d'utiliser Joda Time , une API bien meilleure que Date/Calendar. Il semble que vous devriez utiliser le type LocalDate dans ce cas. Vous pouvez ensuite utiliser:
int days = Days.daysBetween(date1, date2).getDays();
Dans Java 8. Vous pouvez utiliser des instances de Enum ChronoUnit pour calculer la durée en unités différentes (jours, mois, secondes).
Par exemple:
ChronoUnit.DAYS.between(startDate,endDate)
essayez ce code
Calendar cal1 = new GregorianCalendar();
Calendar cal2 = new GregorianCalendar();
SimpleDateFormat sdf = new SimpleDateFormat("ddMMyyyy");
Date date = sdf.parse("your first date");
cal1.setTime(date)
date = sdf.parse("your second date");
cal2.setTime(date);
//cal1.set(2008, 8, 1);
//cal2.set(2008, 9, 31);
System.out.println("Days= "+daysBetween(cal1.getTime(),cal2.getTime()));
cette fonction
public int daysBetween(Date d1, Date d2){
return (int)( (d2.getTime() - d1.getTime()) / (1000 * 60 * 60 * 24));
}
Je sais que ce fil a deux ans maintenant, je ne vois toujours pas de réponse correcte ici.
À moins que vous ne souhaitiez utiliser Joda ou que vous ayez Java 8 et que vous deviez sous-extraire des dates influencées par l'heure d'été.
J'ai donc écrit ma propre solution. L'aspect important est que cela ne fonctionne que si vous vous souciez vraiment des dates car il est nécessaire de supprimer les informations de temps. Si vous voulez quelque chose comme 25.06.2014 - 01.01.2010 = 1636, cela devrait fonctionner quelle que soit l'heure d'été:
private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("dd.MM.yyyy");
public static long getDayCount(String start, String end) {
long diff = -1;
try {
Date dateStart = simpleDateFormat.parse(start);
Date dateEnd = simpleDateFormat.parse(end);
//time is always 00:00:00, so rounding should help to ignore the missing hour when going from winter to summer time, as well as the extra hour in the other direction
diff = Math.round((dateEnd.getTime() - dateStart.getTime()) / (double) 86400000);
} catch (Exception e) {
//handle the exception according to your own situation
}
return diff;
}
Comme l'heure est toujours 00:00:00, utiliser double puis Math.round() devrait aider à ignorer les 3600000 ms (1 heure) manquants pour passer de l'heure d'été à l'heure d'été, ainsi que l'heure supplémentaire si vous passez de l'été à l'hiver.
C’est un petit test JUnit4 que j’utilise pour le prouver:
@Test
public void testGetDayCount() {
String startDateStr = "01.01.2010";
GregorianCalendar gc = new GregorianCalendar(locale);
try {
gc.setTime(simpleDateFormat.parse(startDateStr));
} catch (Exception e) {
}
for (long i = 0; i < 10000; i++) {
String dateStr = simpleDateFormat.format(gc.getTime());
long dayCount = getDayCount(startDateStr, dateStr);
assertEquals("dayCount must be equal to the loop index i: ", i, dayCount);
gc.add(GregorianCalendar.DAY_OF_YEAR, 1);
}
}
... ou si vous voulez voir ce que ça fait 'vie', remplacez cette assertion par simplement:
System.out.println("i: " + i + " | " + dayCount + " - getDayCount(" + startDateStr + ", " + dateStr + ")");
... et voici à quoi devrait ressembler la sortie:
i: 0 | 0 - getDayCount(01.01.2010, 01.01.2010)
i: 1 | 1 - getDayCount(01.01.2010, 02.01.2010)
i: 2 | 2 - getDayCount(01.01.2010, 03.01.2010)
i: 3 | 3 - getDayCount(01.01.2010, 04.01.2010)
...
i: 1636 | 1636 - getDayCount(01.01.2010, 25.06.2014)
...
i: 9997 | 9997 - getDayCount(01.01.2010, 16.05.2037)
i: 9998 | 9998 - getDayCount(01.01.2010, 17.05.2037)
i: 9999 | 9999 - getDayCount(01.01.2010, 18.05.2037)
voici un petit programme qui peut vous aider:
import Java.util.*;
public class DateDifference {
public static void main(String args[]){
DateDifference difference = new DateDifference();
}
DateDifference() {
Calendar cal1 = new GregorianCalendar();
Calendar cal2 = new GregorianCalendar();
cal1.set(2010, 12, 1);
cal2.set(2011, 9, 31);
System.out.println("Days= "+daysBetween(cal1.getTime(),cal2.getTime()));
}
public int daysBetween(Date d1, Date d2) {
return (int)( (d2.getTime() - d1.getTime()) / (1000 * 60 * 60 * 24));
}
}
// http://en.wikipedia.org/wiki/Julian_day
public static int julianDay(int year, int month, int day) {
int a = (14 - month) / 12;
int y = year + 4800 - a;
int m = month + 12 * a - 3;
int jdn = day + (153 * m + 2)/5 + 365*y + y/4 - y/100 + y/400 - 32045;
return jdn;
}
public static int diff(int y1, int m1, int d1, int y2, int m2, int d2) {
return julianDay(y1, m1, d1) - julianDay(y2, m2, d2);
}
Je suis vraiment vraiment vraiment nouveau chez Java, alors je suis sûr qu'il existe un moyen encore meilleur de faire ce que je propose.
J'avais la même demande et je l'ai fait en utilisant la différence entre le DAYOFYEAR des deux dates. Cela semblait un moyen plus facile de le faire ...
Je ne peux pas vraiment évaluer cette solution en termes de performances et de stabilité, mais je pense que ça va.
ici:
public static void main (String [] args) lève ParseException {
// Cette partie du code a été créée uniquement pour créer le variables que je vais utiliser.
// Je suis au Brésil et le format de la date est JJ/MM/AAAA, mais ce ne sera pas un problème pour vous les gars.
// Cela fonctionnera de toute façon avec votre format.
String s1 = "18/09/2014";
String s2 = "01/01/2014";
DateFormat f = DateFormat.getDateInstance ();
Date date1 = f.parse (s1);
Date date2 = f.parse (s2);
// Voici la partie où nous obtenons les jours entre deux dates.
Calendar day1 = Calendar.getInstance ();
Calendar day2 = Calendar.getInstance ();
day1.setTime (date1);
day2.setTime (date2);
int daysBetween = day1.get (Calendar.DAY_OF_YEAR) - day2.get ( Calendar.DAY_OF_YEAR);
// Quelques codes simplement pour afficher le résultat ...
F = DateFormat.getDateInstance (DateFormat. MEDIUM);
System.out.println ("Il y a" + joursEntre + "jours entre" + f.format (day1.getTime ()) + "et" + f.format (day2.getTime ()) + ".");
}
Dans ce cas, la sortie serait (en gardant à l'esprit que j'utilise le format de date JJ/MM/AAAA):
Il y a 260 jours entre le 18/09/2014 et le 01/01/2014.
Cette fonction est bonne pour moi:
public static int getDaysCount(Date begin, Date end) {
Calendar start = org.Apache.commons.lang.time.DateUtils.toCalendar(begin);
start.set(Calendar.MILLISECOND, 0);
start.set(Calendar.SECOND, 0);
start.set(Calendar.MINUTE, 0);
start.set(Calendar.HOUR_OF_DAY, 0);
Calendar finish = org.Apache.commons.lang.time.DateUtils.toCalendar(end);
finish.set(Calendar.MILLISECOND, 999);
finish.set(Calendar.SECOND, 59);
finish.set(Calendar.MINUTE, 59);
finish.set(Calendar.HOUR_OF_DAY, 23);
long delta = finish.getTimeInMillis() - start.getTimeInMillis();
return (int) Math.ceil(delta / (1000.0 * 60 * 60 * 24));
}
Ma meilleure solution (jusqu'à présent) pour calculer la différence en nombre de jours:
// This assumes that you already have two Date objects: startDate, endDate
// Also, that you want to ignore any time portions
Calendar startCale=new GregorianCalendar();
Calendar endCal=new GregorianCalendar();
startCal.setTime(startDate);
endCal.setTime(endDate);
endCal.add(Calendar.YEAR,-startCal.get(Calendar.YEAR));
endCal.add(Calendar.MONTH,-startCal.get(Calendar.Month));
endCal.add(Calendar.DATE,-startCal.get(Calendar.DATE));
int daysDifference=endCal.get(Calendar.DAY_OF_YEAR);
Notez cependant que cela suppose une différence inférieure à un an!