Vérifier si une chaîne Java contient une sous-chaîne

Vérifier si une String apparaît dans une autre est l'une des tâches textuelles les plus courantes en Java. Le bon outil dépend de ce dont vous avez réellement besoin : une simple réponse oui/non, la position de la correspondance, une vérification ancrée au début ou à la fin, ou un motif flexible. Ce chapitre présente chaque approche idiomatique et quand l'utiliser.

Par défaut : `String.contains`

Lorsque vous n'avez besoin que d'un boolean — « ce fragment est-il présent ou non ? » — contains est le choix le plus clair :

String text = "The quick brown fox";
boolean hasFox = text.contains("fox");   // true
boolean hasCat = text.contains("cat");   // false

contains accepte tout CharSequence (donc String, StringBuilder, etc.) et retourne true si l'argument apparaît n'importe où dans la chaîne. Il est sensible à la casse : text.contains("FOX") vaut false. Un cas particulier à retenir — la chaîne vide est contenue dans chaque chaîne, donc text.contains("") est toujours true.

Quand vous avez besoin de la position : `indexOf`

contains est en réalité implémenté au-dessus de indexOf. Si vous devez savoir où commence une correspondance (ou si vous souhaitez rechercher des répétitions), appelez indexOf directement :

String text = "The quick brown fox";
int at = text.indexOf("brown");   // 10
int no = text.indexOf("bird");    // -1

indexOf retourne l'index à base zéro de la première correspondance, ou -1 lorsque la sous-chaîne est absente. L'idiome classique d'appartenance est text.indexOf("brown") >= 0, ce qui est équivalent à contains mais vous donne également la position gratuitement. Il existe aussi lastIndexOf pour chercher depuis la fin, ainsi qu'une surcharge prenant un décalage de départ pour trouver des correspondances successives dans une boucle.

Vérifications ancrées : `startsWith` et `endsWith`

Si vous vous souciez spécifiquement du début ou de la fin d'une chaîne — extensions de fichiers, préfixes d'URL, schémas de protocole — startsWith et endsWith expriment l'intention directement et sont plus lisibles que le découpage :

String file = "report.pdf";
boolean isPdf  = file.endsWith(".pdf");      // true
boolean isHttp = "https://w3docs.com".startsWith("https://"); // true

Ces méthodes sont plus rapides et plus claires que indexOf(prefix) == 0, car elles s'arrêtent dès qu'un caractère diffère et n'analysent jamais toute la chaîne.

Recherche insensible à la casse et par motif

contains n'a pas de surcharge insensible à la casse. La solution la plus simple consiste à normaliser les deux côtés :

boolean ci = text.toLowerCase().contains("FOX".toLowerCase()); // true

Pour plus qu'un fragment littéral — alternatives, caractères génériques, limites de mots — utilisez une expression régulière. Pattern.compile(...).matcher(text).find() retourne true si le motif correspond n'importe où, et CASE_INSENSITIVE gère la casse sans allouer de copies en minuscules :

import java.util.regex.Pattern;
boolean found = Pattern.compile("fox", Pattern.CASE_INSENSITIVE)
                       .matcher(text).find();

Approche	Retourne	Utiliser quand
`contains`	`boolean`	Appartenance simple, texte littéral
`indexOf`	`int` (position, ou `-1`)	Vous avez besoin de savoir où se trouve la correspondance
`startsWith` / `endsWith`	`boolean`	Ancré au début ou à la fin
`Pattern.find`	`boolean`	Motifs, alternatives, insensible à la casse

Un exemple concret

Ce programme exécute les quatre approches côte à côte sur une phrase, y compris le piège de la sensibilité à la casse et le cas particulier de la chaîne vide.

java— editable, runs on the server

public class CheckSubstring {
  public static void main(String[] args) {
    String text = "The quick brown fox jumps over the lazy dog";

// contains(): the simplest yes/no membership test
    System.out.println("contains 'brown'   : " + text.contains("brown"));
    System.out.println("contains 'cat'     : " + text.contains("cat"));

// contains is case-sensitive
    System.out.println("contains 'FOX'     : " + text.contains("FOX"));

// case-insensitive: normalise both sides first
    boolean ci = text.toLowerCase().contains("FOX".toLowerCase());
    System.out.println("contains 'FOX' (ci): " + ci);

// indexOf(): position, or -1 when absent
    System.out.println("indexOf 'fox'      : " + text.indexOf("fox"));
    System.out.println("indexOf 'bird'     : " + text.indexOf("bird"));

// startsWith / endsWith: anchored checks
    System.out.println("startsWith 'The'   : " + text.startsWith("The"));
    System.out.println("endsWith 'dog'     : " + text.endsWith("dog"));

// empty string is always contained
    System.out.println("contains ''        : " + text.contains(""));
  }
}

Ce qu'il faut retenir de l'exécution :

contains "brown" affiche true et contains "cat" affiche false — contains est le test d'appartenance boolean direct pour le texte littéral.
contains "FOX" affiche false même si le mot « fox » est présent, ce qui prouve que contains est sensible à la casse ; la ligne normalisée contains "FOX" (ci) affiche true.
indexOf "fox" affiche 16, la position à base zéro du début de la correspondance, tandis que indexOf "bird" affiche -1 pour signaler « non trouvé » — ce -1 est la valeur sentinelle que vous testez.
startsWith "The" et endsWith "dog" affichent tous deux true, montrant les vérifications ancrées lisant le tout début et la toute fin de la phrase.
contains "" affiche true, rappelant que chaque chaîne contient la chaîne vide — protégez-vous contre les entrées vides si cela constituerait un bug.

Sujets connexes

Java Strings — la base de chaque méthode présentée sur cette page.
Java String Methods — la référence complète pour contains, indexOf, startsWith et leurs homologues.
How to Compare Strings in Java — égalité et ordre, la suite naturelle de l'appartenance.
Java Regex: Pattern and Matcher — approfondissez l'approche par motif présentée ci-dessus.

Pratique

Que retourne text.indexOf('bird') lorsque 'bird' n'est pas présent dans la chaîne text ?

-10nullUne StringIndexOutOfBoundsException est levée

Par défaut : String.contains

Quand vous avez besoin de la position : indexOf

Vérifications ancrées : startsWith et endsWith