Contenu

• Avancer d'un pas
• Méthode 1 sur 4: Utilisation de la commande "compareTo"
• Méthode 2 sur 4: Utilisation des méthodes "égal, après et avant"
• Méthode 3 sur 4: Utilisation de la classe Calendar
• Méthode 4 sur 4: Utilisation de la méthode "getTime"

Il existe plusieurs façons de comparer les dates en Java. En interne, une date est représentée par un point (long) dans le temps - le nombre de millisecondes écoulées depuis le 1er janvier 1970. En Java, date est l'objet Date, ce qui signifie qu'il contient plusieurs méthodes de comparaison des dates. Toute méthode de comparaison de deux dates comparera essentiellement le temps écoulé des deux dates.

Avancer d'un pas

Méthode 1 sur 4: Utilisation de la commande "compareTo"

1. Utilisez compareTo. Date implémente ComparableDate> et ainsi deux dates peuvent être directement comparées l'une à l'autre à l'aide de la méthode compareTo. Si les dates indiquent le même moment dans le temps, la méthode renverra zéro. Si la date comparée est antérieure à l'argument date, une valeur négative sera renvoyée. Si la date comparée est une date postérieure à celle de l'argument date, une valeur positive sera renvoyée. Si les dates sont identiques, un zéro sera renvoyé.
2. Créez les objets Date. Vous devrez créer chaque objet de date avant de pouvoir commencer à les comparer. Une façon de procéder consiste à appliquer la classe SimpleDateFormat. Cela vous permet de saisir facilement des dates dans les objets Date.

   SimpleDateFormat sdf = nouveau SimpleDateFormat ("aaaa-MM-jj"); // Pour déclarer des valeurs dans de nouveaux objets de date.Utilisez le même format de date lors de la création de dates Date date1 = sdf.parse ("1995-02-23"); // date1 est le 23 février 1995 Date date2 = sdf.parse ("2001-10-31"); // date2 est le 31 octobre 2001 Date date3 = sdf.parse ("1995-02-23"); // date3 est le 23 février 1995

3. Comparez les objets de date. Le tableau ci-dessous montre chaque cas - inférieur à, égal à et supérieur à.

   date1.compareTo (date2); // date1 date2, inférieure à 0 date2.compareTo (date1); // date2> date1, renvoie une valeur supérieure à 0 date1.compareTo (date3); // date1 = date3, renvoie 0

Méthode 2 sur 4: Utilisation des méthodes "égal, après et avant"

1. Utilisez des égaux, après et avant. Les dates peuvent être comparées les unes aux autres en utilisant les méthodes égales, après et avant. Si deux dates indiquent la même heure, la méthode equals retournera "true". Les exemples utilisent les dates précédemment créées via la méthode compareTo.
2. Comparez en utilisant la méthode avant. Le code ci-dessous montre un cas de vrai et faux. Si date1 est antérieure à date2, le résultat est vrai. Sinon, before renvoie false.

   System.out.print (date1.before (date2)); // print true System.out.print (date2.before (date2)); // imprimer faux

3. Comparez cela avec la méthode after. Le code ci-dessous montre un cas de vrai et faux. Si date2 est postérieure à date1, alors after renvoie true. Sinon, after renvoie false.

   System.out.print (date2.after (date1)); // print true System.out.print (date1.after (date2)); // print false

4. Comparez en utilisant la méthode égale. Le code ci-dessous montre un cas de vrai et faux. Si les dates sont identiques, equals renvoie true. Sinon, equals renvoie false.

   System.out.print (date1.equals (date3)); // print true System.out.print (date1.equals (date2)); // print false

Méthode 3 sur 4: Utilisation de la classe Calendar

1. Utilisez la classe Calendar. La classe Calendar a également les méthodes compareTo, equals, after et before, qui fonctionnent de la même manière que celle décrite ci-dessus pour la classe de date. Donc, si les données de date sont conservées dans un calendrier, il n'est pas nécessaire d'extraire la "date", juste pour comparer deux dates.
2. Créez une instance de calendrier. Pour utiliser les méthodes de calendrier, vous avez besoin de certaines instances de calendrier. Heureusement, vous pouvez utiliser l'heure telle qu'elle est générée par les instances de Date.

   Calendrier cal1 = Calendar.getInstance (); // déclare cal1 Calendar cal2 = Calendar.getInstance (); // déclare cal2 Calendar cal3 = Calendar.getInstance (); // déclare cal3 cal1.setTime (date1); // applique la date à cal1 cal2.setTime (date2); cal3.setTime (date3);

3. Comparez cal1 et cal2 en utilisant before. Le code ci-dessous renvoie true car cal1 est antérieur à cal2.

   System.out.print (cal1.before (cal2)); // imprime vrai

4. Comparez cal1 et cal2 en utilisant after. Le code ci-dessous renvoie false, car cal1 est antérieur à cal2.

   System.out.print (cal1.after (cal2)); // imprimer faux

5. Comparez cal1 et cal2 en utilisant des égaux. Le code ci-dessous montre un exemple de vrai et faux. La condition dépend des instances de Calendar comparées. Le code ci-dessous renvoie "true" puis "false" sur la ligne suivante.

   System.out.println (cal1.equals (cal3)); // print true: cal1 == cal3 System.out.print (cal1.equals (cal2)); // affiche false: cal1! = cal2

Méthode 4 sur 4: Utilisation de la méthode "getTime"

1. Utilisez getTime. Il est également possible de comparer directement deux points dans le temps, bien que l'une quelconque des approches précédentes soit susceptible de donner des résultats plus lisibles et soit donc préférée. Ceci est une comparaison de deux types de données primitifs, donc peut être fait avec "", ">" et "==".
2. Créez les objets temporels "longs". Avant de pouvoir comparer des dates, vous devez créer des entiers longs à partir des données des objets Date précédemment créés. Heureusement, la méthode getTime () fera l'essentiel du travail à votre place.

   long time1 = getTime (date1); // déclare primitive time1 de date1 long time2 = getTime (date2); // déclare l'heure primitive 2 de date2

3. Utilisez une équation «inférieure à». Utilisez un symbole «inférieur à» () pour comparer ces deux valeurs entières. Puisque time1 est inférieur à time2, le premier message doit être imprimé à l'écran. L'instruction else est incluse pour la syntaxe correcte.

   if (time1 time2) {System.out.println ("date1 est antérieure à date2"); // print car time1 time2} else {System.out.println ("date1 est postérieure ou égale à date2"); }

4. Faites une comparaison «supérieure à». Utilisez le symbole «supérieur à» (>) pour comparer ces deux entiers. Puisque time1 est supérieur à time2, le premier message est imprimé à l'écran. L'instruction else est incluse pour une syntaxe correcte.

   if (time2> time1) {System.out.println ("date2 vient après date1"); // print car time2> time1} else {System.out.println ("date2 est antérieure ou égale à date1"); }

5. Faites une comparaison «égal à». Utilisez le symbole (==) pour comparer ces deux entiers. Puisque time1 est égal à time3, le premier message doit être imprimé. Si le programme accède à l'instruction else, cela signifie que les heures ne sont pas les mêmes.

   if (time1 == time2) {System.out.println ("Les dates sont égales"); } else {System.out.println ("Les dates ne sont pas égales"); // imprimer car time1! = time2}