Comment vérifier si une chaîne commence par un préfixe spécifique en Java

Introduction

Dans ce laboratoire, vous apprendrez à vérifier si une chaîne de caractères commence par un préfixe spécifique en Java en utilisant la méthode startsWith(). Cet exercice pratique vous guidera tout au long de l'application de la méthode startsWith(), du test de son comportement dans différents cas et de la compréhension de la façon dont elle gère les préfixes nuls et vides. À la fin de ce laboratoire, vous maîtriserez cette technique fondamentale de manipulation de chaînes de caractères.

Utiliser startsWith() pour vérifier le préfixe

Dans cette étape, vous apprendrez à utiliser la méthode startsWith() en Java pour vérifier si une chaîne de caractères commence par un préfixe spécifique. Il s'agit d'une opération courante lorsque vous avez besoin de traiter du texte en fonction de son début.

La méthode startsWith() fait partie de la classe String en Java. Elle prend un argument de type String, qui est le préfixe que vous souhaitez vérifier. Elle renvoie true si la chaîne de caractères commence par le préfixe spécifié, et false dans le cas contraire.

Créons un nouveau fichier Java pour pratiquer l'utilisation de startsWith().

Ouvrez l'Explorateur de fichiers sur le côté gauche de l'IDE Web.
Cliquez avec le bouton droit dans le répertoire ~/project et sélectionnez "Nouveau fichier".
Nommez le nouveau fichier PrefixChecker.java.
Ouvrez PrefixChecker.java dans l'éditeur et collez le code suivant :
```
public class PrefixChecker {
    public static void main(String[] args) {
        String text = "Hello, Java!";
        String prefix = "Hello";

        boolean startsWithPrefix = text.startsWith(prefix);

        System.out.println("Does the text start with '" + prefix + "'? " + startsWithPrefix);
    }
}
```
Dans ce code :
- Nous déclarons une variable String nommée text et l'initialisons avec "Hello, Java!".
- Nous déclarons une autre variable String nommée prefix et l'initialisons avec "Hello".
- Nous appelons la méthode startsWith() sur la chaîne text, en passant prefix comme argument. Le résultat (true ou false) est stocké dans la variable boolean startsWithPrefix.
- Enfin, nous affichons le résultat dans la console.
Enregistrez le fichier (Ctrl+S ou Cmd+S).
Maintenant, compilons et exécutons ce programme. Ouvrez le Terminal en bas de l'IDE Web. Assurez-vous que vous êtes dans le répertoire ~/project.
Compilez le fichier Java en utilisant la commande javac :
```
javac PrefixChecker.java
```
S'il n'y a pas d'erreurs, cette commande créera un fichier PrefixChecker.class dans le répertoire ~/project.
Exécutez le programme compilé en utilisant la commande java :
```
java PrefixChecker
```
Vous devriez voir la sortie suivante :
```
Does the text start with 'Hello'? true
```

Cette sortie confirme que la chaîne "Hello, Java!" commence bien par le préfixe "Hello".

Tester le préfixe avec différents cas

Dans l'étape précédente, vous avez utilisé avec succès startsWith() pour vérifier un préfixe. Maintenant, explorons comment startsWith() gère les différentes casse (lettres majuscules et minuscules).

Par défaut, la méthode startsWith() est sensible à la casse. Cela signifie que "Hello" est considéré différent de "hello" ou "HELLO". Modifions notre fichier PrefixChecker.java pour voir cela en action.

Ouvrez le fichier PrefixChecker.java dans l'éditeur de l'IDE Web.

Modifiez la méthode main pour inclure des vérifications avec différentes casse. Remplacez la méthode main existante par le code suivant :

public class PrefixChecker {
    public static void main(String[] args) {
        String text = "Hello, Java!";

        String prefix1 = "Hello";
        String prefix2 = "hello";
        String prefix3 = "HELLO";

        boolean startsWithPrefix1 = text.startsWith(prefix1);
        boolean startsWithPrefix2 = text.startsWith(prefix2);
        boolean startsWithPrefix3 = text.startsWith(prefix3);

        System.out.println("Does the text start with '" + prefix1 + "'? " + startsWithPrefix1);
        System.out.println("Does the text start with '" + prefix2 + "'? " + startsWithPrefix2);
        System.out.println("Does the text start with '" + prefix3 + "'? " + startsWithPrefix3);
    }
}

Dans ce code mis à jour, nous vérifions si la chaîne text commence par "Hello", "hello" et "HELLO".

Enregistrez le fichier (Ctrl+S ou Cmd+S).
Ouvrez le Terminal et assurez-vous que vous êtes dans le répertoire ~/project.
Compilez le fichier Java modifié :
```
javac PrefixChecker.java
```

Exécutez le programme compilé :

java PrefixChecker

Vous devriez voir la sortie suivante :

Does the text start with 'Hello'? true
Does the text start with 'hello'? false
Does the text start with 'HELLO'? false

Cette sortie montre clairement que startsWith() a renvoyé true uniquement pour le préfixe "Hello" (correspondant à la casse de la chaîne originale) et false pour "hello" et "HELLO". Cela démontre que startsWith() est sensible à la casse.

Si vous avez besoin d'effectuer une vérification de préfixe insensible à la casse, vous convertiriez généralement à la fois la chaîne originale et le préfixe en même casse (soit en minuscules, soit en majuscules) avant d'utiliser startsWith(). Par exemple, vous pourriez utiliser text.toLowerCase().startsWith(prefix.toLowerCase()). Nous n'implémenterons pas cela ici, mais c'est une technique utile à garder à l'esprit.

Vérifier les préfixes nuls et vides

Dans cette étape, nous allons étudier le comportement de la méthode startsWith() lorsque le préfixe est null ou une chaîne vide (""). Comprendre ces cas limites est important pour écrire un code robuste.

Ouvrez le fichier PrefixChecker.java dans l'éditeur de l'IDE Web.

Modifiez la méthode main pour tester avec un préfixe null et un préfixe qui est une chaîne vide. Remplacez la méthode main existante par le code suivant :

public class PrefixChecker {
    public static void main(String[] args) {
        String text = "Hello, Java!";

        String prefixNull = null;
        String prefixEmpty = "";

        // Check with a null prefix
        try {
            boolean startsWithPrefixNull = text.startsWith(prefixNull);
            System.out.println("Does the text start with null? " + startsWithPrefixNull);
        } catch (NullPointerException e) {
            System.out.println("Checking with null prefix resulted in: " + e);
        }

        // Check with an empty prefix
        boolean startsWithPrefixEmpty = text.startsWith(prefixEmpty);
        System.out.println("Does the text start with an empty string? " + startsWithPrefixEmpty);
    }
}

Dans ce code mis à jour :

Nous déclarons prefixNull et le définissons sur null.
Nous déclarons prefixEmpty et le définissons sur une chaîne vide "".
Nous utilisons un bloc try-catch lors de la vérification avec prefixNull. En effet, tenter d'appeler une méthode sur un objet null en Java entraîne une NullPointerException. Nous capturons cette exception pour voir ce qui se passe.
Nous effectuons la vérification avec le préfixe qui est une chaîne vide prefixEmpty.

Enregistrez le fichier (Ctrl+S ou Cmd+S).
Ouvrez le Terminal et assurez-vous que vous êtes dans le répertoire ~/project.
Compilez le fichier Java modifié :
```
javac PrefixChecker.java
```

Exécutez le programme compilé :

java PrefixChecker

Vous devriez voir la sortie suivante :

Checking with null prefix resulted in: java.lang.NullPointerException
Does the text start with an empty string? true

Cette sortie démontre deux points importants :

Passer null comme préfixe à startsWith() entraîne une NullPointerException. C'est pourquoi il est crucial de gérer les valeurs potentiellement null avant d'appeler des méthodes sur elles.
Passer une chaîne vide ("") comme préfixe à startsWith() renvoie true. En effet, toute chaîne peut être considérée comme commençant par une chaîne vide.

Comprendre comment startsWith() gère les valeurs null et les chaînes vides est important pour éviter les erreurs et écrire une logique correcte dans vos programmes Java.

Résumé

Dans ce laboratoire, vous avez appris à utiliser la méthode startsWith() en Java pour vérifier si une chaîne commence par un préfixe spécifique. Vous avez pratiqué l'application de cette méthode en créant un simple programme Java, en le compilant et en l'exécutant pour voir la sortie. Cette compétence fondamentale est essentielle pour diverses tâches de manipulation de chaînes en programmation Java.