Comment vérifier si une chaîne de caractères contient une sous-chaîne spécifique en Java

Introduction

Dans ce laboratoire, vous apprendrez à vérifier si une chaîne de caractères contient une sous-chaîne spécifique en Java. Nous explorerons différentes méthodes pour cette tâche courante, en commençant par la méthode simple contains(). Vous apprendrez à utiliser contains() pour déterminer si une chaîne inclut une séquence donnée de caractères et vous pratiquerez l'implémentation de cela dans un simple programme Java.

Après l'introduction à contains(), le laboratoire vous guidera à travers l'utilisation de la méthode indexOf() non seulement pour vérifier la présence d'une sous-chaîne, mais aussi pour trouver sa position dans la chaîne. Enfin, vous apprendrez des techniques pour effectuer des vérifications de sous-chaînes insensibles à la casse, garantissant que votre code peut gérer les variations de capitalisation. À la fin de ce laboratoire, vous aurez une bonne compréhension des différentes approches pour la vérification de sous-chaînes en Java.

Utiliser contains() pour rechercher une sous-chaîne

Dans cette étape, nous apprendrons à vérifier si une chaîne de caractères contient une sous-chaîne spécifique en Java en utilisant la méthode contains(). C'est une tâche courante en programmation, par exemple, lors de la recherche d'un mot-clé dans une phrase ou de la vérification si un nom de fichier contient une certaine extension.

La méthode contains() fait partie de la classe String en Java. Elle retourne true si la chaîne contient la séquence de caractères spécifiée, et false sinon.

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

Ouvrez l'Explorateur de fichiers sur le côté gauche de l'WebIDE.
Assurez-vous que vous êtes dans le répertoire ~/project.
Cliquez avec le bouton droit dans l'espace vide et sélectionnez "Nouveau fichier".
Nommez le nouveau fichier StringContains.java.
Ouvrez le fichier StringContains.java dans l'éditeur.

Copiez et collez le code suivant dans l'éditeur :

public class StringContains {
    public static void main(String[] args) {
        String sentence = "Java programming is fun and powerful.";
        String keyword = "programming";

        // Vérifie si la phrase contient le mot-clé
        boolean containsKeyword = sentence.contains(keyword);

        System.out.println("Sentence: \"" + sentence + "\"");
        System.out.println("Keyword: \"" + keyword + "\"");
        System.out.println("Does the sentence contain the keyword? " + containsKeyword);

        String anotherKeyword = "Python";
        boolean containsAnotherKeyword = sentence.contains(anotherKeyword);

        System.out.println("\nAnother keyword: \"" + anotherKeyword + "\"");
        System.out.println("Does the sentence contain the another keyword? " + containsAnotherKeyword);
    }
}

Dans ce code :

Nous déclarons une variable String sentence et une variable String keyword.
Nous utilisons sentence.contains(keyword) pour vérifier si sentence contient la séquence de caractères dans keyword. Le résultat est stocké dans une variable boolean containsKeyword.
Nous affichons la phrase originale, le mot-clé et le résultat de la vérification contains().
Nous répétons le processus avec un autre mot-clé, "Python", pour voir le résultat lorsque la sous-chaîne n'est pas trouvée.

Enregistrez le fichier (Ctrl+S ou Cmd+S).
Ouvrez le Terminal en bas de l'WebIDE.
Assurez-vous que vous êtes dans le répertoire ~/project en utilisant la commande :
```
cd ~/project
```
Compilez le programme Java en utilisant la commande javac :
```
javac StringContains.java
```
S'il n'y a pas d'erreurs, vous ne verrez aucun résultat. Un fichier StringContains.class sera créé dans le répertoire ~/project.

Exécutez le programme Java compilé en utilisant la commande java :

java StringContains

Vous devriez voir un résultat similaire à ceci :

Sentence: "Java programming is fun and powerful."
Keyword: "programming"
Does the sentence contain the keyword? true

Another keyword: "Python"
Does the sentence contain the another keyword? false

Ce résultat montre que la méthode contains() a correctement identifié que la phrase contient "programming" mais pas "Python".

Explorer indexOf() pour la position d'une sous-chaîne

Dans l'étape précédente, nous avons appris à vérifier si une chaîne de caractères contient une sous-chaîne en utilisant contains(). Maintenant, explorons une autre méthode utile, indexOf(), qui non seulement nous indique si une sous-chaîne existe, mais nous donne également sa position de départ dans la chaîne.

La méthode indexOf() de la classe String en Java retourne l'indice (index) dans la chaîne de la première occurrence de la sous-chaîne spécifiée. L'indice est la position du premier caractère de la sous-chaîne. N'oubliez pas que en programmation, l'indexation commence généralement à 0. Si la sous-chaîne n'est pas trouvée, indexOf() retourne -1.

Modifions notre fichier Java précédent, StringContains.java, pour utiliser la méthode indexOf().

Ouvrez le fichier StringContains.java dans l'éditeur de l'WebIDE.

Remplacez tout le contenu du fichier par le code suivant :

public class StringContains {
    public static void main(String[] args) {
        String sentence = "Java programming is fun and powerful.";
        String keyword = "programming";

        // Trouver l'indice du mot-clé
        int index = sentence.indexOf(keyword);

        System.out.println("Sentence: \"" + sentence + "\"");
        System.out.println("Keyword: \"" + keyword + "\"");

        if (index != -1) {
            System.out.println("The keyword \"" + keyword + "\" was found at index: " + index);
        } else {
            System.out.println("The keyword \"" + keyword + "\" was not found.");
        }

        String anotherKeyword = "Python";
        int anotherIndex = sentence.indexOf(anotherKeyword);

        System.out.println("\nAnother keyword: \"" + anotherKeyword + "\"");

        if (anotherIndex != -1) {
            System.out.println("The keyword \"" + anotherKeyword + "\" was found at index: " + anotherIndex);
        } else {
            System.out.println("The keyword \"" + anotherKeyword + "\" was not found.");
        }
    }
}

Dans ce code mis à jour :

Nous utilisons sentence.indexOf(keyword) pour trouver l'indice de départ du keyword dans la sentence. Le résultat est stocké dans une variable int appelée index.
Nous utilisons une instruction if pour vérifier si l'index retourné est -1. Si ce n'est pas -1, cela signifie que le mot-clé a été trouvé, et nous affichons son indice. Sinon, nous affichons un message indiquant que le mot-clé n'a pas été trouvé.
Nous répétons le processus pour "Python" pour démontrer le cas où la sous-chaîne n'est pas présente.

Enregistrez le fichier (Ctrl+S ou Cmd+S).
Ouvrez le Terminal en bas de l'WebIDE.
Assurez-vous que vous êtes dans le répertoire ~/project.
Compilez le programme Java modifié :
```
javac StringContains.java
```

Exécutez le programme Java compilé :

java StringContains

Vous devriez voir un résultat similaire à ceci :

Sentence: "Java programming is fun and powerful."
Keyword: "programming"
The keyword "programming" was found at index: 5

Another keyword: "Python"
The keyword "Python" was not found.

Le résultat montre que "programming" commence à l'indice 5 dans la phrase (en rappelant que 'J' est à l'indice 0, 'a' est à l'indice 1, et ainsi de suite, y compris l'espace). Il indique également correctement que "Python" n'a pas été trouvé.

L'utilisation de indexOf() est un moyen puissant non seulement de vérifier la présence d'une sous-chaîne, mais aussi de déterminer sa position exacte, ce qui peut être utile pour diverses tâches de manipulation de chaînes de caractères.

Effectuer une vérification de sous-chaîne insensible à la casse

Dans les étapes précédentes, nous avons utilisé contains() et indexOf() pour rechercher des sous-chaînes. Cependant, ces méthodes sont sensibles à la casse. Cela signifie que "Java" est considéré différent de "java" ou "JAVA". Dans de nombreuses situations, vous pourriez vouloir effectuer une recherche insensible à la casse.

La classe String de Java n'a pas de méthode intégrée comme containsIgnoreCase() ou indexOfIgnoreCase(). Cependant, nous pouvons obtenir une recherche insensible à la casse en convertissant à la même casse (soit en minuscules, soit en majuscules) la chaîne originale et la sous-chaîne avant d'effectuer la recherche. L'approche la plus courante est de convertir les deux en minuscules en utilisant la méthode toLowerCase().

Modifions à nouveau notre fichier StringContains.java pour effectuer une recherche insensible à la casse.

Ouvrez le fichier StringContains.java dans l'éditeur de l'WebIDE.

Remplacez tout le contenu du fichier par le code suivant :

public class StringContains {
    public static void main(String[] args) {
        String sentence = "Java programming is fun and powerful.";
        String keyword = "JAVA"; // Utilisation de majuscules à des fins de démonstration

        // Convertir les deux chaînes en minuscules pour une comparaison insensible à la casse
        String lowerSentence = sentence.toLowerCase();
        String lowerKeyword = keyword.toLowerCase();

        // Utiliser contains() sur les chaînes en minuscules
        boolean containsKeyword = lowerSentence.contains(lowerKeyword);

        System.out.println("Original Sentence: \"" + sentence + "\"");
        System.out.println("Original Keyword: \"" + keyword + "\"");
        System.out.println("Does the sentence contain the keyword (case-insensitive)? " + containsKeyword);

        // Vous pouvez également utiliser indexOf() de manière insensible à la casse
        int index = lowerSentence.indexOf(lowerKeyword);

        if (index != -1) {
            System.out.println("The keyword \"" + keyword + "\" was found at index (case-insensitive): " + index);
        } else {
            System.out.println("The keyword \"" + keyword + "\" was not found (case-insensitive).");
        }
    }
}

Dans ce code :

Nous définissons le keyword comme "JAVA" (en majuscules).
Nous créons de nouvelles chaînes lowerSentence et lowerKeyword en convertissant les chaînes originales en minuscules à l'aide de toLowerCase().
Nous utilisons ensuite la méthode contains() sur les chaînes en minuscules pour effectuer une vérification insensible à la casse.
Nous montrons également comment utiliser indexOf() de manière insensible à la casse en l'appliquant aux chaînes en minuscules.

Enregistrez le fichier (Ctrl+S ou Cmd+S).
Ouvrez le Terminal en bas de l'WebIDE.
Assurez-vous que vous êtes dans le répertoire ~/project.
Compilez le programme Java modifié :
```
javac StringContains.java
```

Exécutez le programme Java compilé :

java StringContains

Vous devriez voir un résultat similaire à ceci :

Original Sentence: "Java programming is fun and powerful."
Original Keyword: "JAVA"
Does the sentence contain the keyword (case-insensitive)? true
The keyword "JAVA" was found at index (case-insensitive): 0

Ce résultat montre que même si le mot-clé original était "JAVA" (en majuscules), la recherche insensible à la casse l'a correctement trouvé dans la phrase et a indiqué son indice (qui est 0 pour "Java" en minuscules).

En convertissant les chaînes à une casse cohérente avant la recherche, vous pouvez facilement effectuer des vérifications de sous-chaînes insensibles à la casse en Java.

Résumé

Dans ce laboratoire (lab), nous avons appris à vérifier si une chaîne de caractères contient une sous-chaîne spécifique en Java. Nous avons commencé par utiliser la méthode contains(), qui effectue une vérification booléenne simple pour la présence d'une sous-chaîne. Cette méthode est simple d'utilisation et utile pour les vérifications de base de l'existence d'une sous-chaîne.

Nous avons ensuite exploré la méthode indexOf(), qui non seulement vérifie la présence d'une sous-chaîne, mais retourne également l'indice de départ de la première occurrence. Cela permet d'analyser plus en détail la position de la sous-chaîne dans la chaîne. Enfin, nous avons abordé la demande courante de réaliser des vérifications de sous-chaînes insensibles à la casse, en démontrant des techniques pour y parvenir indépendamment de la casse de la chaîne originale.