Comment vérifier si un nombre est égal à zéro en Java

Introduction

Dans ce laboratoire (lab), vous apprendrez à vérifier si un nombre est égal à zéro en Java. Cette compétence fondamentale est essentielle pour contrôler le flux du programme à l'aide d'instructions conditionnelles. Nous commencerons par explorer l'utilisation de l'opérateur d'égalité (==) pour comparer des valeurs entières à zéro.

Ensuite, nous aborderons les considérations spécifiques et les pièges potentiels lors de la manipulation de nombres à virgule flottante et de zéro en raison des problèmes de précision. Enfin, nous examinerons comment effectuer des vérifications de zéro lorsque vous travaillez avec les classes d'encapsulation (wrapper classes) de Java pour les types primitifs.

Skills Graph

Utilisation de l'opérateur d'égalité pour vérifier l'égalité à zéro

Dans cette étape, nous allons explorer comment vérifier si un nombre est égal à zéro en Java en utilisant l'opérateur d'égalité. Il s'agit d'une opération fondamentale en programmation, souvent utilisée dans les instructions conditionnelles pour contrôler le flux de votre programme.

En Java, l'opérateur d'égalité est représenté par ==. Il est utilisé pour comparer deux valeurs et renvoie true si elles sont égales, et false sinon.

Créons un simple programme Java pour illustrer cela.

1. Ouvrez le fichier HelloJava.java dans l'éditeur WebIDE s'il n'est pas déjà ouvert.

2. Remplacez tout le contenu du fichier par le code suivant :

   public class HelloJava {
       public static void main(String[] args) {
           int number = 0;
   
           if (number == 0) {
               System.out.println("The number is zero.");
           } else {
               System.out.println("The number is not zero.");
           }
       }
   }

   Analysons ce nouveau code :

   • int number = 0; : Cette ligne déclare une variable entière nommée number et l'initialise avec la valeur 0.
   • if (number == 0) : Il s'agit d'une instruction if, qui est utilisée pour prendre des décisions dans votre code. La condition entre parenthèses (number == 0) vérifie si la valeur de la variable number est égale à 0.
   • System.out.println("The number is zero."); : Cette ligne sera exécutée uniquement si la condition number == 0 est true.
   • else : Ce mot-clé introduit le bloc de code qui sera exécuté si la condition de l'instruction if est false.
   • System.out.println("The number is not zero."); : Cette ligne sera exécutée uniquement si la condition number == 0 est false.

3. Enregistrez le fichier (Ctrl+S ou Cmd+S).

4. Maintenant, compilons notre programme modifié. Dans le terminal, assurez-vous d'être dans le répertoire ~/project. Vous pouvez utiliser cd ~/project si nécessaire. Ensuite, exécutez :

   javac HelloJava.java

   Si la compilation réussit, vous ne verrez aucun message de sortie.

5. Enfin, exécutons notre programme :

   java HelloJava

   Vous devriez voir la sortie suivante :

   The number is zero.

   Cela confirme que notre programme a correctement vérifié si la variable number était égale à zéro en utilisant l'opérateur ==.

Maintenant, essayez de changer la valeur de la variable number en une valeur non nulle (par exemple, int number = 5;), enregistrez le fichier, recompilez-le et exécutez le programme à nouveau pour voir la sortie différente.

Gérer la précision des nombres à virgule flottante

Dans cette étape, nous allons explorer un problème courant lorsqu'on travaille avec des nombres à virgule flottante (nombres avec une partie décimale) en programmation : la précision. En raison de la manière dont les ordinateurs stockent ces nombres, les comparaisons d'égalité directes utilisant == peuvent parfois conduire à des résultats inattendus.

Voyons cela en action.

1. Ouvrez le fichier HelloJava.java dans l'éditeur WebIDE.

2. Remplacez le code existant par le suivant :

   public class HelloJava {
       public static void main(String[] args) {
           double num1 = 0.1 + 0.2;
           double num2 = 0.3;
   
           System.out.println("num1: " + num1);
           System.out.println("num2: " + num2);
   
           if (num1 == num2) {
               System.out.println("num1 is equal to num2.");
           } else {
               System.out.println("num1 is not equal to num2.");
           }
       }
   }

   Dans ce code :

   • Nous déclarons deux variables de type double, num1 et num2. double est un type de données en Java utilisé pour stocker des nombres à virgule flottante.
   • Nous assignons 0.1 + 0.2 à num1 et 0.3 à num2. Mathématiquement, ces valeurs devraient être égales.
   • Nous affichons les valeurs de num1 et num2 pour voir leur représentation exacte.
   • Nous utilisons l'opérateur == pour vérifier si num1 est égal à num2.

3. Enregistrez le fichier (Ctrl+S ou Cmd+S).

4. Compilez le programme dans le terminal :

   javac HelloJava.java

5. Exécutez le programme compilé :

   java HelloJava

   Vous serez peut-être surpris par la sortie :

   num1: 0.30000000000000004
   num2: 0.3
   num1 is not equal to num2.

   Comme vous pouvez le voir, num1 n'est pas exactement égal à 0.3 en raison de la manière dont les nombres à virgule flottante sont stockés. C'est un problème courant et c'est pourquoi il est généralement déconseillé de comparer directement des nombres à virgule flottante pour vérifier leur égalité en utilisant ==.

Pour gérer ce problème, au lieu de vérifier l'égalité exacte, nous vérifions généralement si la différence absolue entre les deux nombres est inférieure à une très petite tolérance (souvent appelée un "epsilon").

Modifions le code pour utiliser cette approche.

1. Ouvrez à nouveau HelloJava.java.

2. Remplacez l'instruction if par le code suivant :

   double epsilon = 0.000001; // A small tolerance
   
   if (Math.abs(num1 - num2) < epsilon) {
       System.out.println("num1 is approximately equal to num2.");
   } else {
       System.out.println("num1 is not approximately equal to num2.");
   }

   Ici :

   • Nous définissons une petite valeur d'epsilon.
   • Math.abs(num1 - num2) calcule la différence absolue entre num1 et num2.
   • Nous vérifions si cette différence absolue est inférieure à notre epsilon.

3. Enregistrez le fichier.

4. Compilez le programme :

   javac HelloJava.java

5. Exécutez le programme :

   java HelloJava

   Maintenant, la sortie devrait être :

   num1: 0.30000000000000004
   num2: 0.3
   num1 is approximately equal to num2.

   Cela démontre la bonne façon de comparer des nombres à virgule flottante pour vérifier leur égalité pratique en tenant compte des limitations de précision.

Tester avec les classes d'emballage (Wrapper Classes)

Dans cette étape, nous allons explorer le fonctionnement de la comparaison d'égalité avec les classes d'emballage (wrapper classes) de Java. Les classes d'emballage sont des classes spéciales qui permettent d'utiliser les types de données primitifs (comme int, double, boolean) sous forme d'objets. Par exemple, la classe d'emballage pour int est Integer, et pour double est Double.

Lorsque l'on compare des objets en Java, l'opérateur == vérifie si les deux variables font référence au même objet exact en mémoire, et non si leurs valeurs sont égales. Pour comparer les valeurs des objets, vous devriez utiliser la méthode equals().

Voyons comment cela s'applique aux classes d'emballage.

1. Ouvrez le fichier HelloJava.java dans l'éditeur WebIDE.

2. Remplacez le code existant par le suivant :

   public class HelloJava {
       public static void main(String[] args) {
           Integer intObj1 = new Integer(100);
           Integer intObj2 = new Integer(100);
           Integer intObj3 = intObj1; // intObj3 refers to the same object as intObj1
   
           System.out.println("Comparing Integer objects with ==:");
           if (intObj1 == intObj2) {
               System.out.println("intObj1 == intObj2 is true");
           } else {
               System.out.println("intObj1 == intObj2 is false");
           }
   
           if (intObj1 == intObj3) {
               System.out.println("intObj1 == intObj3 is true");
           } else {
               System.out.println("intObj1 == intObj3 is false");
           }
   
           System.out.println("\nComparing Integer objects with equals():");
           if (intObj1.equals(intObj2)) {
               System.out.println("intObj1.equals(intObj2) is true");
           } else {
               System.out.println("intObj1.equals(intObj2) is false");
           }
   
           if (intObj1.equals(intObj3)) {
               System.out.println("intObj1.equals(intObj3) is true");
           } else {
               System.out.println("intObj1.equals(intObj3) is false");
           }
       }
   }

   Dans ce code :

   • Nous créons deux objets Integer, intObj1 et intObj2, avec la même valeur (100) en utilisant new Integer(). Cela crée deux objets distincts en mémoire.
   • Nous créons intObj3 et lui assignons intObj1. Cela signifie que intObj3 et intObj1 pointent maintenant vers le même objet en mémoire.
   • Nous utilisons == pour comparer intObj1 avec intObj2 et intObj3.
   • Nous utilisons la méthode equals() pour comparer les valeurs de intObj1 avec intObj2 et intObj3.

3. Enregistrez le fichier (Ctrl+S ou Cmd+S).

4. Compilez le programme dans le terminal :

   javac HelloJava.java

5. Exécutez le programme compilé :

   java HelloJava

   La sortie devrait être :

   Comparing Integer objects with ==:
   intObj1 == intObj2 is false
   intObj1 == intObj3 is true
   
   Comparing Integer objects with equals():
   intObj1.equals(intObj2) is true
   intObj1.equals(intObj3) is true

   Cette sortie montre clairement la différence :

   • intObj1 == intObj2 est false car ils sont des objets différents en mémoire, même si leurs valeurs sont les mêmes.
   • intObj1 == intObj3 est true car ils font référence au même objet exact.
   • intObj1.equals(intObj2) est true car la méthode equals() compare les valeurs des objets, qui sont toutes deux 100.
   • intObj1.equals(intObj3) est également true car ils font référence au même objet, et leurs valeurs sont les mêmes.

   Note importante : Pour les petites valeurs entières (généralement de -128 à 127), Java utilise un cache pour les objets Integer. Cela signifie que Integer intObjA = 50; Integer intObjB = 50; pourrait entraîner intObjA == intObjB étant true car ils pourraient faire référence au même objet mis en cache. Cependant, il n'est pas recommandé de s'appuyer sur ce comportement de mise en cache pour les vérifications d'égalité. Utilisez toujours la méthode equals() pour comparer les valeurs des objets de classes d'emballage.

Cette étape met en évidence la différence cruciale entre la comparaison de types primitifs et d'objets en Java et l'importance d'utiliser la méthode equals() pour comparer les valeurs des objets.

Résumé

Dans ce laboratoire (lab), nous avons appris à vérifier si un nombre est égal à zéro en Java. Nous avons commencé par utiliser l'opérateur d'égalité fondamental (==) pour comparer une variable entière à zéro dans une instruction if. Cela a démontré le principe de base des vérifications conditionnelles basées sur l'égalité numérique.

Nous avons ensuite exploré les subtilités de la manipulation des nombres à virgule flottante et les problèmes de précision potentiels qui apparaissent lorsqu'on les compare directement à zéro en utilisant ==. Enfin, nous avons examiné comment effectuer des vérifications de zéro avec les classes d'emballage (wrapper classes) de Java, en comprenant comment accéder et comparer les valeurs primitives sous-jacentes.