Discussion :

[djodjo]

Bonjour tout le monde,

Voila, j'ai deux date, java.util.date, et je souhaite connaitre la différence en année entre ces deux dates :

par exemple entre 01/03/2002 et 01/02/2005 c'est egal a deux ans ...

Voila est ce que vous connaissez quelques choses qui faite cela???

J'ai chercher et je ne trouve pas ...

Merci

[divxdede]

Bonjour tout le monde,

Voila, j'ai deux date, java.util.date, et je souhaite connaitre la différence en année entre ces deux dates :

par exemple entre 01/03/2002 et 01/02/2005 c'est egal a deux ans ...

Voila est ce que vous connaissez quelques choses qui faite cela???

J'ai chercher et je ne trouve pas ...

Merci

Tout dépends de ce que tu veux ?

Si pour toi 30/12/2005 et 02/01/2006 il y a 1 an alors tu peu simplement faire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
Calendar dateA = ....;
Calendar dateB = ....;
 
int dYear = Math.abs( dateA.get( Calendar.YEAR ) - dateB.get( Calendar.YEAR ) );

[djodjo]

Merci de ta réponse,

Justement je n'estime pas que entre 30/12/2005 et 02/01/2006 il y a un an, je compte les année que entre 30/12/2005 et 30/12/2006 Voilà et c'est la mon probleme !!!

[divxdede]

J'écrirais une méthode de ce style:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
package test;
 
import java.util.Calendar;
import java.util.GregorianCalendar;
 
/**
 * Test pour difference de dates (sur l'année)
 * @author André Sébastien.
 */
public class TestDate {
 
    /** Creates a new instance of TestDate */
    public TestDate() {
    }
 
    /** Return the number of complete year since dateA between dateA and dateB
     *  @param dateA Minimum date threshold
     *  @param dateB Maximum date threshold
     *  
     *  Remark: if dateA > dateB, dateB is used as minimum threshold.
     *  
     *  @return Complete years since dateA between dateA and dateB
     */
    public static int diffYear(Calendar dateA , Calendar dateB )
    {   if( dateA == null || dateB == null ) throw new IllegalArgumentException("dateA and dateB can't be null");
 
        Calendar minDate = ( dateA.compareTo(dateB) > 0 ? dateB : dateA );
        Calendar maxDate = ( minDate == dateA ? dateB : dateA );
 
        Calendar dummyDate = (Calendar)maxDate.clone();
                 dummyDate.set( Calendar.DAY_OF_MONTH , minDate.get( Calendar.DAY_OF_MONTH ) );
                 dummyDate.set( Calendar.MONTH , minDate.get( Calendar.MONTH ) );
 
        boolean lastYearCompleted = (dummyDate.compareTo(maxDate) < 0);
 
        int delta = maxDate.get(Calendar.YEAR) - minDate.get(Calendar.YEAR);
        if( ! lastYearCompleted ) delta = delta - 1;
 
        // Result
        int result = Math.max( delta , 0 );
        System.out.println("Difference = " + result);
        return result;
    }
 
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
 
        // 01/03/2002 - 01/02/2005 == 2
        diffYear( new GregorianCalendar(2002,02,01) , new GregorianCalendar(2005,01,01) );
 
        // 24/07/2004 - 28/09/2004 == 0
        diffYear( new GregorianCalendar(2004,06,24) , new GregorianCalendar(2004,8,28) );
 
        // 13/03/2003 - 20/07/2005 == 2
        diffYear( new GregorianCalendar(2003,02,13) , new GregorianCalendar(2005,06,20) );
 
        // 13/03/2003 - 12/03/2005 == 1
        diffYear( new GregorianCalendar(2003,02,13) , new GregorianCalendar(2005,02,12) );
    }
}

[djodjo]

Je te remercie de ta réponse et désolé de te répondre si tard a mon tour !!!

C'est bon ca marche super bien !!!

Par contre au début je pensais qu'il existait déjà une méthode pour réaliser cela, suis déçu !!!!
lol

merci en tout cas !!!

[ALEX731]

Et pour avoir l'écart en jour ?
est on obligé d'écrire une méthode de ce style ou y a-t-il une méthode existante ?

compareTo() me dit seulement laquelle des 2 dates est la plus grande il me semble...

[ALEX731]

Bon j'ai fait comme ça :

Calendar calendar1 = Calendar.getInstance();
calendar1.setTime(date1); //affectation de date1 dans le calendar1
int annee1 = calendar1.get(Calendar.YEAR);
int jour1 = calendar1.get(Calendar.DAY_OF_YEAR);

Calendar calendar2 = Calendar.getInstance();
calendar2.setTime(date2); //affectation de date1 dans le calendar1
int annee2 = calendar2.get(Calendar.YEAR);
int jour2 = calendar2.get(Calendar.DAY_OF_YEAR);

if (annee1 == annee2){
/*meme annee => écart entre les 2 jours*/
nbJour = jour2 - jour1;
}else{
int ecartAnnee = annee2 - annee1;
nbJour = jour2+(365*ecartAnnee)- jour1;
}

C'est moyen car ça ne prend pas en compte les années bissextiles mais dans mon cas je ne suis pas à un jours près...

[McFoggy]

En me basant sur un exemple trouvé sur JavaWorld, j'ai écrit une petite classe utilitaire qui devrait t'aider.

Tu trouveras un exemple d'utilisation à la fin du code.

Au passage si un modérateur veut ajouter ce code aux sources Java de développez qu'il ne se gène pas (Envoyez moi un MP si besoin de documentation).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
package test;
 
import java.text.DateFormat;
import java.text.MessageFormat;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.List;
 
public class ElapsedTime {
	private static final List TIME_CONSTANTS = Arrays.asList(new Integer[] {
		new Integer(Calendar.MILLISECOND)
		, new Integer(Calendar.SECOND)
		, new Integer(Calendar.MINUTE)
		, new Integer(Calendar.HOUR_OF_DAY)
		, new Integer(Calendar.DATE)
		, new Integer(Calendar.MONTH)
		, new Integer(Calendar.YEAR)
	});
 
	public static long elapsedTime(GregorianCalendar c1, GregorianCalendar c2, int type) {
		return elapsedTime(c1, c2, type, false);
	}
 
	public static long elapsedTime(GregorianCalendar c1, GregorianCalendar c2, int type, boolean clear) {
		long elapsed = 0;
 
		GregorianCalendar gc1;
		GregorianCalendar gc2;
 
		Integer t = new Integer(type);
 
		if (!TIME_CONSTANTS.contains(t)) {
			throw new IllegalArgumentException("bad required Calendar type for elapsed time calculation");
		}
 
		if (c1.before(c2)) {
			gc1 = (GregorianCalendar) c1.clone();
			gc2 = (GregorianCalendar) c2.clone();
		} else {
			gc1 = (GregorianCalendar) c2.clone();
			gc2 = (GregorianCalendar) c1.clone();
		}
 
		// At this point "gc1 <= gc2"
		if (clear) {
			// We only clear MILLISECONDS, SECONDS, MINUTE, HOUR regarding the type asked 
			for (int i = 0; i <= TIME_CONSTANTS.indexOf(t) && i < 4; i++) {
				gc1.set(((Integer)TIME_CONSTANTS.get(i)).intValue(), 0);
				gc2.set(((Integer)TIME_CONSTANTS.get(i)).intValue(), 0);
			}
		}
 
		// Regarding what we ask for elpased time
		// We use different calculation type
		if (TIME_CONSTANTS.indexOf(t) > 3) {
			// With such a computation Calendar is responsible of bissextil years and more problems on date
	        gc1.add(t.intValue(), 1);
			while (gc1.before(gc2) || gc1.equals(gc2)) {
		         gc1.add(t.intValue(), 1);
		         elapsed++;
			}
		} else {
			// A faster one for MILLISECONDS/SECONDS/MINUTES/HOUR
			long millis = gc2.getTimeInMillis() - gc1.getTimeInMillis();
			if (type==Calendar.MILLISECOND) {
				elapsed = millis;
			} else if (type==Calendar.SECOND) {
				elapsed = millis / 1000;
			} else if (type==Calendar.MINUTE) {
				elapsed = millis / (1000 * 60);
			} else if (type==Calendar.HOUR_OF_DAY) {
				elapsed = millis / (1000 * 60 * 24);
			}
		}
		return elapsed;
	}
 
	public static void main(String[] args) {
		GregorianCalendar c1 = new GregorianCalendar(2002, 02, 01);
		GregorianCalendar c2 = new GregorianCalendar(2005, 01, 01);
 
		printElapsedTime(c1, c2, true);
 
		c1 = new GregorianCalendar(2002, 02, 01, 12, 0, 0);
		c2 = new GregorianCalendar(2002, 02, 01, 15, 1, 1);
 
		printElapsedTime(c1, c2, false);
		c2.set(Calendar.MILLISECOND, 115);
		printElapsedTime(c1, c2, false);
		printElapsedTime(c1, c2, true);
	}
 
	private static void printElapsedTime(GregorianCalendar c1, GregorianCalendar c2, boolean clear) {
		DateFormat df = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss SSS");
		System.out.println(MessageFormat.format("calcul de temps écoulé entre {0} et {1}, clear mode [{2}]", new Object[] {df.format(c1.getTime()), df.format(c2.getTime()), Boolean.valueOf(clear)}));
		System.out.println("années: " + ElapsedTime.elapsedTime(c1, c2, Calendar.YEAR, clear));
		System.out.println("mois: " + ElapsedTime.elapsedTime(c1, c2, Calendar.MONTH, clear));
		System.out.println("jours: " + ElapsedTime.elapsedTime(c1, c2, Calendar.DATE, clear));
		System.out.println("heures: " + ElapsedTime.elapsedTime(c1, c2, Calendar.HOUR_OF_DAY, clear));
		System.out.println("minutes: " + ElapsedTime.elapsedTime(c1, c2, Calendar.MINUTE, clear));
		System.out.println("secondes: " + ElapsedTime.elapsedTime(c1, c2, Calendar.SECOND, clear));
		System.out.println("millis: " + ElapsedTime.elapsedTime(c1, c2, Calendar.MILLISECOND, clear));
		System.out.println("");
	}
}

Matthieu