Comment vérifier si un tableau en Java a une longueur spécifique

JavaJavaBeginner
Pratiquer maintenant

💡 Ce tutoriel est traduit par l'IA à partir de la version anglaise. Pour voir la version originale, vous pouvez cliquer ici

Introduction

Dans ce laboratoire (lab), vous apprendrez à vérifier si un tableau (array) en Java a une longueur spécifique. Nous commencerons par comprendre comment déterminer la taille d'un tableau en utilisant la propriété intégrée length.

Ensuite, vous apprendrez à comparer la longueur du tableau avec une valeur attendue pour vérifier si elle correspond à une taille souhaitée. Enfin, nous explorerons comment gérer les tableaux nuls (null arrays) lors de la vérification de leur longueur pour éviter les erreurs potentielles.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL java(("Java")) -.-> java/BasicSyntaxGroup(["Basic Syntax"]) java(("Java")) -.-> java/DataStructuresGroup(["Data Structures"]) java(("Java")) -.-> java/ObjectOrientedandAdvancedConceptsGroup(["Object-Oriented and Advanced Concepts"]) java/BasicSyntaxGroup -.-> java/if_else("If...Else") java/DataStructuresGroup -.-> java/arrays("Arrays") java/DataStructuresGroup -.-> java/arrays_methods("Arrays Methods") java/ObjectOrientedandAdvancedConceptsGroup -.-> java/exceptions("Exceptions") subgraph Lab Skills java/if_else -.-> lab-560000{{"Comment vérifier si un tableau en Java a une longueur spécifique"}} java/arrays -.-> lab-560000{{"Comment vérifier si un tableau en Java a une longueur spécifique"}} java/arrays_methods -.-> lab-560000{{"Comment vérifier si un tableau en Java a une longueur spécifique"}} java/exceptions -.-> lab-560000{{"Comment vérifier si un tableau en Java a une longueur spécifique"}} end

Utilisation de la propriété length pour la taille d'un tableau

Dans cette étape, nous apprendrons à déterminer la taille d'un tableau en Java en utilisant la propriété length. Comprendre la taille d'un tableau est essentiel pour parcourir ses éléments ou effectuer des opérations qui dépendent du nombre d'éléments qu'il contient.

En Java, les tableaux ont une propriété intégrée appelée length qui stocke le nombre d'éléments que le tableau peut contenir. Cette propriété est une variable finale, ce qui signifie que sa valeur ne peut pas être modifiée après la création du tableau.

Créons un simple programme Java pour démontrer comment utiliser la propriété length.

  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) {
            // Declare and initialize an integer array
            int[] numbers = {10, 20, 30, 40, 50};
    
            // Get the length of the array using the length property
            int arraySize = numbers.length;
    
            // Print the size of the array
            System.out.println("The size of the array is: " + arraySize);
        }
    }

    Examinons les nouvelles parties de ce code :

    • int[] numbers = {10, 20, 30, 40, 50}; : Cette ligne déclare un tableau d'entiers nommé numbers et l'initialise avec cinq valeurs entières.
    • int arraySize = numbers.length; : C'est ici que nous utilisons la propriété length. numbers.length accède à la taille du tableau numbers, et nous stockons cette valeur dans une variable entière appelée arraySize.
    • System.out.println("The size of the array is: " + arraySize); : Cette ligne affiche la valeur stockée dans la variable arraySize dans la console.
  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 en exécutant cd ~/project. 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 size of the array is: 5

    Cette sortie confirme que la propriété length a correctement renvoyé le nombre d'éléments dans notre tableau numbers.

Comprendre comment obtenir la taille d'un tableau est crucial pour de nombreuses tâches de programmation, telles que la boucle sur tous les éléments ou l'allocation de mémoire pour de nouveaux tableaux.

Comparaison avec la longueur attendue

Dans cette étape, nous allons nous appuyer sur notre compréhension de la propriété length en comparant la taille réelle d'un tableau avec une taille attendue. C'est une tâche courante en programmation, notamment lors de la validation des entrées ou de la garantie de l'intégrité des données.

Nous pouvons utiliser des instructions conditionnelles (comme les instructions if) pour vérifier si la longueur du tableau correspond à une valeur spécifique.

Modifions notre programme HelloJava.java pour comparer la longueur du tableau avec une valeur attendue.

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

  2. Remplacez le code actuel par le suivant :

    public class HelloJava {
        public static void main(String[] args) {
            int[] numbers = {10, 20, 30, 40, 50};
            int expectedSize = 5; // We expect the array to have 5 elements
    
            int arraySize = numbers.length;
    
            System.out.println("The size of the array is: " + arraySize);
            System.out.println("The expected size is: " + expectedSize);
    
            // Compare the actual size with the expected size
            if (arraySize == expectedSize) {
                System.out.println("The array size matches the expected size.");
            } else {
                System.out.println("The array size does NOT match the expected size.");
            }
        }
    }

Voici ce qui est nouveau :

  • int expectedSize = 5; : Nous déclarons une variable entière expectedSize et la définissons à 5, qui est la taille que nous attendons pour notre tableau numbers.
  • System.out.println("The expected size is: " + expectedSize); : Nous affichons la taille attendue pour plus de clarté.
  • if (arraySize == expectedSize) : Il s'agit d'une instruction if qui vérifie si la valeur de arraySize est égale à la valeur de expectedSize. L'opérateur == est utilisé pour la comparaison.
  • System.out.println("The array size matches the expected size."); : Cette ligne est exécutée si la condition de l'instruction if est vraie (les tailles correspondent).
  • else : Ce mot-clé introduit le bloc de code à exécuter si la condition de l'instruction if est fausse.
  • System.out.println("The array size does NOT match the expected size."); : Cette ligne est exécutée si la condition de l'instruction if est fausse (les tailles ne correspondent pas).
  1. Enregistrez le fichier (Ctrl+S ou Cmd+S).

  2. Compilez le programme modifié dans le terminal :

    javac HelloJava.java
  3. Exécutez le programme compilé :

    java HelloJava

Vous devriez voir une sortie similaire à celle-ci :

The size of the array is: 5
The expected size is: 5
The array size matches the expected size.

Cette sortie montre que notre programme a correctement comparé la taille réelle du tableau (5) avec la taille attendue (5) et a affiché le message approprié.

Vous pouvez essayer de modifier la valeur de expectedSize ou d'ajouter/supprimer des éléments du tableau numbers pour voir comment la sortie change. Cet exercice vous aide à comprendre comment la logique conditionnelle fonctionne avec les propriétés des tableaux.

Test avec des tableaux null

Dans cette étape finale, nous allons explorer ce qui se passe lorsque vous essayez d'accéder à la propriété length d'un tableau qui n'a pas été initialisé, ou qui est null. Comprendre comment gérer les valeurs null est crucial pour éviter les erreurs dans vos programmes.

En Java, une variable qui est déclarée mais n'est pas affectée à une référence d'objet a une valeur par défaut de null. Si vous essayez d'accéder à une propriété ou à une méthode d'un objet null, Java lancera une NullPointerException. C'est une erreur d'exécution courante que vous rencontrerez en programmation Java.

Modifions notre programme pour voir ce qui se passe lorsque nous essayons d'accéder à la longueur (length) d'un tableau null et comment le gérer de manière appropriée.

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

  2. Remplacez le code actuel par le suivant :

    public class HelloJava {
        public static void main(String[] args) {
            int[] numbers = null; // Declare an array but set it to null
    
            // Attempt to access the length property (this will cause an error)
            // int arraySize = numbers.length; // Commenting this out to prevent error
    
            // How to safely check for null before accessing length
            if (numbers != null) {
                int arraySize = numbers.length;
                System.out.println("The size of the array is: " + arraySize);
            } else {
                System.out.println("The array is null. Cannot get its length.");
            }
        }
    }

Voici une explication des modifications :

  • int[] numbers = null; : Nous déclarons le tableau numbers mais nous lui attribuons explicitement la valeur null. Cela signifie que la variable numbers ne fait actuellement référence à aucun objet tableau en mémoire.
  • // int arraySize = numbers.length; : Nous avons commenté la ligne qui tente d'accéder directement à numbers.length. Si nous exécutions ce code sans la vérification if, cela entraînerait une NullPointerException.
  • if (numbers != null) : C'est la partie cruciale pour gérer les valeurs null. Nous utilisons une instruction if pour vérifier si la variable numbers n'est pas null. L'opérateur != signifie "différent de".
  • int arraySize = numbers.length; System.out.println("The size of the array is: " + arraySize); : Ce bloc de code n'est exécuté que si numbers n'est pas null. À l'intérieur de ce bloc, il est sûr d'accéder à numbers.length.
  • else : Ce bloc est exécuté si la condition de l'instruction if est fausse, c'est-à-dire si numbers est null.
  • System.out.println("The array is null. Cannot get its length."); : Ce message est affiché lorsque le tableau est null, informant l'utilisateur que la longueur ne peut pas être déterminée.
  1. Enregistrez le fichier (Ctrl+S ou Cmd+S).

  2. Compilez le programme modifié dans le terminal :

    javac HelloJava.java
  3. Exécutez le programme compilé :

    java HelloJava

Vous devriez voir la sortie suivante :

The array is null. Cannot get its length.

Cette sortie démontre que notre programme a correctement identifié que le tableau était null et a géré la situation sans lancer de NullPointerException.

Gérer les valeurs null est une compétence très importante en programmation Java. Vérifiez toujours si une référence d'objet est null avant d'essayer d'accéder à ses propriétés ou méthodes pour éviter les erreurs d'exécution.

Résumé

Dans ce laboratoire (lab), nous avons appris à déterminer la taille d'un tableau en Java en utilisant la propriété intégrée length. Cette propriété offre un moyen simple d'accéder au nombre d'éléments qu'un tableau peut contenir. Nous avons démontré cela en créant un tableau d'entiers, en accédant à sa longueur (length) et en affichant le résultat.

Les étapes suivantes s'appuieront probablement sur ce concept fondamental pour comparer la taille du tableau avec une longueur attendue et gérer les scénarios potentiels de tableaux null, renforçant ainsi notre compréhension de la manipulation de tableaux en Java.