Comment vérifier si une chaîne de caractères se termine par un suffixe spécifique en Java

Introduction

Dans ce laboratoire, vous apprendrez à vérifier si une chaîne de caractères se termine par un suffixe spécifique en Java. Il s'agit d'une compétence fondamentale pour des tâches telles que la validation des types de fichiers ou l'analyse de données en fonction de leur fin. Vous allez explorer la méthode endsWith(), comprendre sa sensibilité à la casse et apprendre à la combiner avec startsWith() pour des vérifications plus complexes. Grâce à des exemples pratiques, vous acquerrez une expérience concrète dans l'utilisation de ces techniques de manipulation de chaînes dans vos programmes Java.

Utiliser endsWith() pour vérifier un suffixe

Dans cette étape, nous allons explorer comment utiliser la méthode endsWith() en Java pour vérifier si une chaîne de caractères se termine par un suffixe spécifique. Il s'agit d'une tâche courante lorsque vous avez besoin de valider les extensions de fichiers, de vérifier des motifs spécifiques ou de traiter des données en fonction de leur fin.

La méthode endsWith() fait partie de la classe String en Java. Elle prend un seul argument, qui est le suffixe que vous souhaitez vérifier, et renvoie une valeur booléenne : true si la chaîne se termine par le suffixe spécifié, et false sinon.

Créons un simple programme Java pour démontrer le fonctionnement de endsWith().

Ouvrez le fichier HelloJava.java dans l'éditeur WebIDE. Si vous ne l'avez pas ouvert, vous le trouverez dans l'Explorateur de fichiers à gauche, dans le dossier project.

Remplacez le code existant dans HelloJava.java par le suivant :

public class HelloJava {
    public static void main(String[] args) {
        String fileName = "document.txt";
        boolean endsWithTxt = fileName.endsWith(".txt");

        System.out.println("Does '" + fileName + "' end with '.txt'? " + endsWithTxt);

        String imageUrl = "photo.jpg";
        boolean endsWithJpg = imageUrl.endsWith(".jpg");

        System.out.println("Does '" + imageUrl + "' end with '.jpg'? " + endsWithJpg);

        String documentName = "report.pdf";
        boolean endsWithDoc = documentName.endsWith(".doc");

        System.out.println("Does '" + documentName + "' end with '.doc'? " + endsWithDoc);
    }
}

Dans ce code :

Nous déclarons trois variables de type String : fileName, imageUrl et documentName.
Nous utilisons la méthode endsWith() sur chaque chaîne pour vérifier si elle se termine par un suffixe spécifique (.txt, .jpg, .doc).
Les résultats (true ou false) sont stockés dans des variables booléennes (endsWithTxt, endsWithJpg, endsWithDoc).
Enfin, nous affichons les résultats dans la console à l'aide de System.out.println().

Enregistrez le fichier HelloJava.java (Ctrl+S ou Cmd+S).
Maintenant, compilons le programme. Ouvrez le Terminal en bas de l'IDE Web et assurez-vous que vous êtes dans le répertoire ~/project. Ensuite, exécutez la commande suivante :
```
javac HelloJava.java
```
S'il n'y a pas d'erreurs, la compilation se terminera silencieusement et un fichier HelloJava.class sera créé dans le répertoire ~/project.
Enfin, exécutez le programme compilé en utilisant la commande java :
```
java HelloJava
```
Vous devriez voir une sortie similaire à ceci :
```
Does 'document.txt' end with '.txt'? true
Does 'photo.jpg' end with '.jpg'? true
Does 'report.pdf' end with '.doc'? false
```
Cette sortie montre les résultats de nos vérifications avec endsWith(), confirmant que document.txt se termine par .txt, photo.jpg se termine par .jpg et que report.pdf ne se termine pas par .doc.

Vous avez utilisé avec succès la méthode endsWith() pour vérifier les suffixes de chaînes de caractères. Il s'agit d'une opération fondamentale que vous utiliserez fréquemment en programmation Java.

Tester un suffixe avec sensibilité à la casse

Dans l'étape précédente, nous avons appris à utiliser la méthode endsWith(). Il est important de comprendre que la méthode endsWith() en Java effectue une comparaison sensible à la casse. Cela signifie que "file.txt" se termine par ".txt", mais ne se termine pas par ".TXT".

Modifions notre programme pour observer cette sensibilité à la casse en action.

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

Remplacez le code existant par le suivant :

public class HelloJava {
    public static void main(String[] args) {
        String fileName = "document.txt";

        // Vérification sensible à la casse
        boolean endsWithLowercaseTxt = fileName.endsWith(".txt");
        System.out.println("Does '" + fileName + "' end with '.txt' (lowercase)? " + endsWithLowercaseTxt);

        // Vérification sensible à la casse avec suffixe en majuscules
        boolean endsWithUppercaseTxt = fileName.endsWith(".TXT");
        System.out.println("Does '" + fileName + "' end with '.TXT' (uppercase)? " + endsWithUppercaseTxt);

        String anotherFile = "IMAGE.JPG";

        // Vérification sensible à la casse avec suffixe en minuscules
        boolean endsWithLowercaseJpg = anotherFile.endsWith(".jpg");
        System.out.println("Does '" + anotherFile + "' end with '.jpg' (lowercase)? " + endsWithLowercaseJpg);

        // Vérification sensible à la casse avec suffixe en majuscules
        boolean endsWithUppercaseJpg = anotherFile.endsWith(".JPG");
        System.out.println("Does '" + anotherFile + "' end with '.JPG' (uppercase)? " + endsWithUppercaseJpg);
    }
}

Dans ce code mis à jour, nous testons explicitement endsWith() avec des suffixes en minuscules et en majuscules pour mettre en évidence la sensibilité à la casse de la méthode.

Enregistrez le fichier HelloJava.java.
Compilez le programme modifié dans le Terminal :
```
javac HelloJava.java
```

Exécutez le programme compilé :

java HelloJava

Vous devriez voir une sortie similaire à ceci :

Does 'document.txt' end with '.txt' (lowercase)? true
Does 'document.txt' end with '.TXT' (uppercase)? false
Does 'IMAGE.JPG' end with '.jpg' (lowercase)? false
Does 'IMAGE.JPG' end with '.JPG' (uppercase)? true

Comme vous pouvez le voir, la méthode endsWith() a renvoyé false lorsque la casse du suffixe ne correspondait pas exactement à celle de la chaîne.

Si vous avez besoin d'effectuer une vérification insensible à la casse, vous convertirez généralement à la même casse (soit en minuscules, soit en majuscules) la chaîne et le suffixe avant d'utiliser endsWith(). Nous ne couvrirons pas cela dans cette étape spécifique, mais c'est une technique utile à garder à l'esprit.

Comprendre la sensibilité à la casse est crucial lorsque vous travaillez avec des chaînes en Java, car de nombreuses méthodes de manipulation de chaînes sont sensibles à la casse par défaut.

Combiner les vérifications startsWith() et endsWith()

En plus de vérifier la fin d'une chaîne de caractères avec endsWith(), vous pouvez également vérifier le début d'une chaîne en utilisant la méthode startsWith(). Cette méthode fonctionne de manière similaire à endsWith(), prenant un préfixe en argument et renvoyant true si la chaîne commence par ce préfixe, et false sinon. Comme endsWith(), startsWith() est également sensible à la casse.

La combinaison de startsWith() et endsWith() vous permet d'effectuer des vérifications plus spécifiques sur les chaînes de caractères. Par exemple, vous pourriez vouloir vérifier si un nom de fichier commence par "temp_" et se termine par ".log".

Mettons à jour notre programme pour utiliser à la fois startsWith() et endsWith().

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

Remplacez le code existant par le suivant :

public class HelloJava {
    public static void main(String[] args) {
        String logFileName = "temp_application_error.log";

        boolean startsWithTemp = logFileName.startsWith("temp_");
        boolean endsWithLog = logFileName.endsWith(".log");

        System.out.println("Does '" + logFileName + "' start with 'temp_'? " + startsWithTemp);
        System.out.println("Does '" + logFileName + "' end with '.log'? " + endsWithLog);

        // Combine checks using the logical AND operator (&&)
        boolean isTempLogFile = startsWithTemp && endsWithLog;
        System.out.println("Is '" + logFileName + "' a temporary log file? " + isTempLogFile);

        String anotherFile = "data_report.txt";

        boolean startsWithData = anotherFile.startsWith("data_");
        boolean endsWithTxt = anotherFile.endsWith(".txt");

        System.out.println("Does '" + anotherFile + "' start with 'data_'? " + startsWithData);
        System.out.println("Does '" + anotherFile + "' end with '.txt'? " + endsWithTxt);

        boolean isDataTxtFile = startsWithData && endsWithTxt;
        System.out.println("Is '" + anotherFile + "' a data text file? " + isDataTxtFile);
    }
}

Dans ce code :

Nous introduisons la méthode startsWith() pour vérifier le début des chaînes de caractères.
Nous utilisons l'opérateur logique ET (&&) pour combiner les résultats de startsWith() et endsWith(). L'opérateur && renvoie true seulement si les deux conditions sont true.

Enregistrez le fichier HelloJava.java.
Compilez le programme dans le Terminal :
```
javac HelloJava.java
```

Exécutez le programme compilé :

java HelloJava

Vous devriez voir une sortie similaire à ceci :

Does 'temp_application_error.log' start with 'temp_'? true
Does 'temp_application_error.log' end with '.log'? true
Is 'temp_application_error.log' a temporary log file? true
Does 'data_report.txt' start with 'data_'? true
Does 'data_report.txt' end with '.txt'? true
Is 'data_report.txt' a data text file? true

Cette sortie montre comment vous pouvez utiliser startsWith() et endsWith() ensemble avec des opérateurs logiques pour effectuer des vérifications de chaînes de caractères plus complexes.

Vous avez maintenant appris à utiliser à la fois startsWith() et endsWith() et à les combiner pour vérifier à la fois le début et la fin d'une chaîne de caractères. Ces méthodes sont des outils fondamentaux pour la manipulation et la validation de chaînes de caractères en Java.

Résumé

Dans ce laboratoire (lab), nous avons appris à vérifier si une chaîne de caractères se termine par un suffixe spécifique en Java en utilisant la méthode endsWith(). Nous avons exploré son utilisation de base pour vérifier des suffixes tels que les extensions de fichiers et avons observé comment elle renvoie une valeur booléenne indiquant si la chaîne se termine par le suffixe spécifié.

Nous avons également étudié la sensibilité à la casse de la méthode endsWith() et appris à effectuer des vérifications insensibles à la casse en convertissant la chaîne et le suffixe dans la même casse avant la comparaison. Enfin, nous avons combiné les méthodes startsWith() et endsWith() pour vérifier si une chaîne commence et se termine par des préfixes et des suffixes spécifiques, démontrant ainsi comment ces méthodes peuvent être utilisées ensemble pour une validation de chaînes de caractères plus complexe.