Comment vérifier si un nombre est de type Long en Java

Introduction

Dans ce laboratoire (lab), nous explorerons différentes méthodes pour déterminer si un nombre en Java est de type Long. Nous commencerons par apprendre à utiliser l'opérateur instanceof pour vérifier si un objet est une instance de la classe wrapper Long.

Ensuite, nous plongerons dans le parsing de chaînes de caractères en valeurs Long, en comprenant comment gérer les erreurs potentielles pendant ce processus. Enfin, nous ferons la distinction entre les types Long et Integer, en mettant en évidence leurs principales différences et comment travailler efficacement avec chacun d'eux.

Skills Graph

Vérifier l'instance de la classe Long

Dans cette étape, nous explorerons la classe Long en Java et apprendrons à vérifier si un objet est une instance de la classe Long.

En Java, les types de données primitifs comme long ne sont pas des objets. Cependant, Java fournit des classes wrapper (classes d'emballage) pour chaque type primitif, et Long est la classe wrapper pour le type primitif long. Les classes wrapper nous permettent de traiter les valeurs primitives comme des objets, ce qui est utile dans de nombreuses situations, par exemple lorsqu'on travaille avec des collections.

Pour vérifier si un objet est une instance d'une classe spécifique, nous utilisons l'opérateur instanceof. L'opérateur instanceof est un opérateur binaire utilisé pour tester si un objet est une instance d'une classe, d'une sous - classe ou d'une interface.

Créons un simple programme Java pour démontrer comment utiliser l'opérateur instanceof avec la classe Long.

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) {
           // Create a Long object
           Long myLong = 12345L;
   
           // Create an Integer object
           Integer myInteger = 67890;
   
           // Check if myLong is an instance of Long
           if (myLong instanceof Long) {
               System.out.println("myLong is an instance of Long.");
           } else {
               System.out.println("myLong is not an instance of Long.");
           }
   
           // Check if myInteger is an instance of Long
           if (myInteger instanceof Long) {
               System.out.println("myInteger is an instance of Long.");
           } else {
               System.out.println("myInteger is not an instance of Long.");
           }
       }
   }

   Dans ce code :

   • Nous créons un objet Long nommé myLong avec la valeur 12345L. Le suffixe L indique qu'il s'agit d'un littéral long.
   • Nous créons un objet Integer nommé myInteger avec la valeur 67890.
   • Nous utilisons l'opérateur instanceof pour vérifier si myLong est une instance de Long.
   • Nous utilisons l'opérateur instanceof pour vérifier si myInteger est une instance de Long.

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

4. Compilez le programme en exécutant la commande suivante dans le terminal :

   javac HelloJava.java

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

5. Exécutez le programme compilé :

   java HelloJava

   Vous devriez voir la sortie suivante :

   myLong is an instance of Long.
   myInteger is not an instance of Long.

Cette sortie confirme que myLong, que nous avons créé comme objet Long, est bien une instance de la classe Long, tandis que myInteger, créé comme objet Integer, ne l'est pas.

Convertir une chaîne de caractères en Long

Dans cette étape, nous apprendrons à convertir une représentation sous forme de chaîne de caractères (String) d'un nombre en un objet Long ou en un type primitif long. C'est une tâche courante lorsque vous recevez des données numériques sous forme de texte, par exemple, à partir d'une saisie utilisateur ou d'un fichier.

La classe Long fournit des méthodes statiques pour effectuer cette conversion. Les deux méthodes les plus couramment utilisées sont :

• Long.parseLong(String s) : Cette méthode analyse l'argument de type chaîne de caractères comme un entier signé décimal de type long. Elle retourne une valeur primitive de type long.
• Long.valueOf(String s) : Cette méthode retourne un objet Long contenant la valeur représentée par l'argument de type chaîne de caractères.

Modifions notre programme HelloJava.java pour démontrer comment convertir une chaîne de caractères en un long et en un Long.

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) {
           String numberString = "9876543210";
   
           // Parse the string to a primitive long
           long primitiveLong = Long.parseLong(numberString);
           System.out.println("Parsed primitive long: " + primitiveLong);
   
           // Parse the string to a Long object
           Long longObject = Long.valueOf(numberString);
           System.out.println("Parsed Long object: " + longObject);
   
           // Demonstrate parsing a different string
           String anotherNumberString = "112233445566";
           long anotherPrimitiveLong = Long.parseLong(anotherNumberString);
           System.out.println("Parsed another primitive long: " + anotherPrimitiveLong);
       }
   }

   Dans ce code :

   • Nous définissons une variable de type String nommée numberString contenant le texte "9876543210".
   • Nous utilisons Long.parseLong() pour convertir numberString en un long primitif et le stockons dans primitiveLong.
   • Nous utilisons Long.valueOf() pour convertir numberString en un objet Long et le stockons dans longObject.
   • Nous démontrons la conversion d'une autre chaîne de caractères pour montrer la flexibilité de la méthode.

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

4. Compilez le programme :

   javac HelloJava.java

   Assurez-vous qu'il n'y a pas d'erreurs de compilation.

5. Exécutez le programme :

   java HelloJava

   Vous devriez voir une sortie similaire à celle-ci :

   Parsed primitive long: 9876543210
   Parsed Long object: 9876543210
   Parsed another primitive long: 112233445566

Cette sortie montre que tant Long.parseLong() que Long.valueOf() ont réussi à convertir les représentations sous forme de chaîne de caractères de nombres en leurs valeurs correspondantes de type long et Long.

Il est important de noter que si la chaîne de caractères ne contient pas un nombre valide pouvant être représenté comme un long, ces méthodes lanceront une NumberFormatException. Nous ne couvrirons pas la gestion des erreurs dans ce laboratoire de base, mais c'est quelque chose à garder à l'esprit pour les applications réelles.

Différencier Long d'Integer

Dans cette étape, nous allons nous concentrer sur la compréhension des principales différences entre long (et sa classe wrapper Long) et int (et sa classe wrapper Integer) en Java. Bien que les deux servent à stocker des nombres entiers, ils diffèrent considérablement en termes de plage de valeurs qu'ils peuvent contenir et de leur utilisation mémoire.

La principale différence réside dans leur taille :

• int : Un int est un entier signé en complément à deux sur 32 bits. Cela signifie qu'il peut stocker des valeurs allant de -2 147 483 648 à 2 147 483 647.
• long : Un long est un entier signé en complément à deux sur 64 bits. Cela lui permet de stocker une plage de valeurs beaucoup plus large, allant de -9 223 372 036 854 775 808 à 9 223 372 036 854 775 807.

Modifions notre programme HelloJava.java pour illustrer cette différence.

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) {
           // Maximum value for int
           int maxInt = Integer.MAX_VALUE;
           System.out.println("Maximum value of int: " + maxInt);
   
           // Trying to store a value larger than maxInt in an int (will cause error if uncommented)
           // int tooBigInt = 2147483648; // This line would cause a compilation error
   
           // A value larger than maxInt, stored in a long
           long largeLong = 2147483648L; // Note the 'L' suffix
           System.out.println("A large value stored in long: " + largeLong);
   
           // Maximum value for long
           long maxLong = Long.MAX_VALUE;
           System.out.println("Maximum value of long: " + maxLong);
   
           // Demonstrating the size difference with literals
           System.out.println("Size of int in bits: " + Integer.SIZE);
           System.out.println("Size of long in bits: " + Long.SIZE);
       }
   }

   Dans ce code :

   • Nous affichons la valeur maximale qu'un int peut contenir en utilisant Integer.MAX_VALUE.
   • Nous montrons une ligne commentée qui causerait une erreur de compilation si elle était décommentée, car la valeur 2147483648 est supérieure à la valeur maximale d'un int.
   • Nous stockons la même grande valeur dans une variable long nommée largeLong, en utilisant le suffixe L pour indiquer qu'il s'agit d'un littéral long.
   • Nous affichons la valeur maximale qu'un long peut contenir en utilisant Long.MAX_VALUE.
   • Nous affichons la taille en bits de int et de long en utilisant Integer.SIZE et Long.SIZE.

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

4. Compilez le programme :

   javac HelloJava.java

   Assurez-vous qu'il n'y a pas d'erreurs de compilation.

5. Exécutez le programme :

   java HelloJava

   Vous devriez voir une sortie similaire à celle-ci :

   Maximum value of int: 2147483647
   A large value stored in long: 2147483648
   Maximum value of long: 9223372036854775807
   Size of int in bits: 32
   Size of long in bits: 64

Cette sortie démontre clairement que long peut contenir des valeurs considérablement plus grandes que int, et confirme leurs tailles respectives en bits. Lorsque vous choisissez entre int et long, tenez compte de la plage de valeurs que votre variable doit stocker. Utilisez int pour les nombres plus petits afin d'économiser de la mémoire, et long pour les nombres plus grands.

Résumé

Dans ce laboratoire, nous avons appris à vérifier si un nombre est de type Long en Java. Nous avons exploré la classe wrapper Long et sa relation avec le type primitif long. Nous nous sommes particulièrement concentrés sur l'utilisation de l'opérateur instanceof pour déterminer si un objet est une instance de la classe Long. À travers un exemple pratique, nous avons démontré comment appliquer instanceof pour différencier les objets Long et Integer.