Maîtriser contains() en Java : comment effectuer des recherches de sous‑chaînes efficaces

1. Introduction : Pourquoi la recherche de chaînes est importante en Java

La manipulation de chaînes est l’une des opérations les plus fréquemment utilisées lors de la programmation en Java.
Que ce soit pour vérifier une saisie utilisateur, analyser le contenu d’un fichier ou rechercher des mots‑clés spécifiques, il faut souvent déterminer si un mot particulier se trouve dans une chaîne donnée.
Pour répondre à ces besoins, Java propose une méthode pratique appelée contains().
Grâce à cette méthode, vous pouvez facilement savoir si une chaîne contient partiellement une autre.
Par exemple, si vous voulez vérifier si un message d’erreur contient un mot‑clé précis, contains() vous le permet en une seule ligne de code.
Surtout dans les scénarios impliquant de gros volumes de texte — comme les applications web, le traitement d’API ou l’analyse de logs — la méthode contains() améliore grandement la lisibilité et la maintenabilité du code.
Cependant, il existe aussi des considérations importantes telles que la sensibilité à la casse et la gestion du null.
Cet article explique en détail la méthode contains() de Java : de son utilisation de base et des erreurs courantes aux différences avec d’autres méthodes et aux applications pratiques.
Notre objectif est de fournir des informations utiles non seulement aux débutants, mais aussi aux développeurs qui utilisent Java dans des projets réels.

2. Syntaxe de base et caractéristiques de la méthode contains()

La méthode contains() de Java détermine si une chaîne contient partiellement une autre chaîne.
Sa syntaxe est très simple, pourtant elle est très pratique et utilisée fréquemment dans les tâches de programmation quotidiennes.

Syntaxe de base

boolean result = targetString.contains(searchString);

La méthode appartient à la classe String et accepte un CharSequence (généralement un String) comme argument.
Sa valeur de retour est un boolean : true si la chaîne cible contient la sous‑chaîne fournie, et false sinon.

Exemple de code

String message = "Java programming is fun!";
boolean hasKeyword = message.contains("programming");

System.out.println(hasKeyword); // Output: true

Dans l’exemple ci‑dessus, la sous‑chaîne "programming" est présente dans la chaîne cible, donc contains() renvoie true.

Caractéristiques de la méthode

• Vérifie uniquement une correspondance partielle : si vous avez besoin d’une correspondance exacte, utilisez equals() à la place.
• Sensible à la casse : par exemple, "Java" et "java" sont considérés comme différents (détails expliqués plus loin).
• Ne supporte pas les expressions régulières : comme elle se contente de vérifier la présence d’une chaîne, le filtrage par motif nécessite matches() ou la classe Pattern.

Comportement lorsqu’on passe null

Passer null à contains() déclenche une NullPointerException.
Par exemple, le code suivant lèvera une :

String text = null;
System.out.println(text.contains("test")); // Exception occurs

De même, si la chaîne cible elle‑même est null, la même exception sera levée.
Il est donc fortement recommandé d’effectuer des vérifications de nullité avant d’appeler contains().

3. Exemples d’utilisation pratique et considérations importantes

La méthode contains() de Java est très intuitive et pratique, mais une mauvaise utilisation peut entraîner des bugs inattendus ou un code inefficace.
Cette section explique l’utilisation de base de contains() ainsi que les points clés à connaître.

3‑1. Exemple d’utilisation de base

Le code suivant montre un exemple simple de vérification de la présence d’un mot‑clé dans la chaîne cible :

String sentence = "今日はJavaの勉強をしています。";

if (sentence.contains("Java")) {
    System.out.println("Javaが含まれています。");
} else {
    System.out.println("Javaは含まれていません。");
}

Comme le montre l’exemple, contains() est souvent combiné avec des instructions if pour réaliser des branchements conditionnels.

3‑2. Sensibilité à la casse

La méthode contains() est sensible à la casse.
Par exemple, le code suivant renvoie false :

String text = "Welcome to Java";
System.out.println(text.contains("java")); // false

Dans de tels cas, il est courant d’convertir les chaînes en minuscules (ou en majuscules) avant la comparaison :

String text = "Welcome to Java";
System.out.println(text.toLowerCase().contains("java")); // true

Cette approche aide à éliminer les différences de casse dans l’entrée (par exemple, entrée utilisateur).

3-3. Gestion de null et des chaînes vides

L’une des considérations les plus importantes lors de l’utilisation de contains() est la gestion de null. Si la chaîne cible ou l’argument est null, une NullPointerException se produira.

String text = null;
System.out.println(text.contains("test")); // Runtime error

Pour éviter ce problème, ajoutez toujours une vérification de null :

if (text != null && text.contains("test")) {
    // Safe to process
}

Notez également : Passer une chaîne vide ("") retourne toujours true.

String sample = "test";
System.out.println(sample.contains("")); // true

Cependant, ce comportement est rarement utile en pratique et peut involontairement entraîner des bugs si des chaînes vides sont passées par inadvertance.

3-4. Ne prend pas en charge les recherches de mots-clés multiples

contains() ne peut vérifier qu’un mot-clé à la fois. Pour vérifier plusieurs mots-clés, vous devez soit appeler contains() plusieurs fois, soit utiliser l’API Stream.

String target = "エラーコード123：アクセス拒否";
if (target.contains("エラー") || target.contains("拒否")) {
    System.out.println("問題のあるメッセージです。");
}

Ou, pour des ensembles de mots-clés dynamiques :

List<String> keywords = Arrays.asList("エラー", "障害", "失敗");
boolean found = keywords.stream().anyMatch(target::contains);

4. Méthodes fréquemment comparées à contains()

Java fournit plusieurs méthodes pour comparer des chaînes ou vérifier si une sous-chaîne spécifique existe. Parmi elles, contains() est utilisé pour les « correspondances partielles », mais d’autres méthodes servent également des objectifs similaires. Cette section explique les caractéristiques et les différences de ces méthodes pour vous aider à les utiliser de manière appropriée.

4-1. Différence avec equals() : Correspondance exacte vs. Correspondance partielle

equals() détermine si deux chaînes sont exactement identiques. En revanche, contains() vérifie les correspondances partielles.

String a = "Java";
String b = "Java";

System.out.println(a.equals(b));      // true: Exact match
System.out.println(a.contains("av")); // true: Partial match

Différences principales :

Directive d’utilisation : Utilisez equals() lorsque les valeurs doivent correspondre exactement (par exemple, vérification d’ID). Utilisez contains() lorsque les correspondances partielles sont acceptables (par exemple, recherche de mots-clés).

4-2. Différence avec indexOf() : Si vous avez besoin de la position

La méthode indexOf() peut également être utilisée pour vérifier si une sous-chaîne existe dans une chaîne. La différence est que indexOf() retourne l’indice de départ de la sous-chaîne si elle est trouvée. Si la sous-chaîne n’est pas trouvée, elle retourne -1.

String text = "Hello, Java World!";
System.out.println(text.indexOf("Java"));    // 7
System.out.println(text.indexOf("Python"));  // -1

Vous pouvez également utiliser indexOf() pour reproduire le comportement de contains() :

if (text.indexOf("Java") >= 0) {
    System.out.println("It is contained.");
}

Directive d’utilisation : Si vous n’avez pas besoin de l’indice, contains() est plus lisible et préférable.

4-3. Différence avec matches() : Support des expressions régulières

La méthode matches() vérifie si une chaîne correspond complètement à une expression régulière donnée. En revanche, contains() ne vérifie que les correspondances de sous-chaînes littérales et ne prend pas en charge les regex.

String text = "abc123";
System.out.println(text.matches(".*123")); // true
System.out.println(text.contains(".*123")); // false (not regex)

Si vous voulez une correspondance partielle basée sur les regex, utilisez la classe Pattern :

4-4. Résumé de la comparaison des fonctionnalités

5. Cas d’utilisation courants et code d’exemple

La méthode contains() de Java est simple mais largement utilisée dans les scénarios de développement réels. Les cas d’utilisation typiques incluent la validation des entrées utilisateur, l’analyse de logs et les opérations de filtrage. Cette section couvre des exemples pratiques avec le code correspondant.

5-1. Validation des entrées utilisateur (Détection des mots interdits)

Dans les formulaires ou les applications de chat, vous pourriez avoir besoin de détecter si certains mots prohibés sont inclus.

String input = "このアプリは最悪だ";
String banned = "最悪";

if (input.contains(banned)) {
    System.out.println("不適切な言葉が含まれています。");
}

Gestion de plusieurs mots NG :

List<String> bannedWords = Arrays.asList("最悪", "バカ", "死ね");
for (String word : bannedWords) {
    if (input.contains(word)) {
        System.out.println("不適切な言葉が含まれています: " + word);
        break;
    }
}

5-2. Analyse des fichiers de journal (Détection de messages spécifiques)

Lors de l’analyse des journaux système ou d’application, vous pourriez vouloir extraire uniquement les lignes contenant des mots-clés spécifiques comme ERROR ou WARN.

List<String> logs = Arrays.asList(
    "[INFO] サーバーが起動しました",
    "[ERROR] データベース接続失敗",
    "[WARN] メモリ使用率が高い"
);

for (String log : logs) {
    if (log.contains("ERROR")) {
        System.out.println("エラー発生ログ: " + log);
    }
}

5-3. Filtrage de chaînes dans une liste (Utilisation de l’API Stream)

Lors de la gestion de grands ensembles de données, utilisez l’API Stream pour extraire uniquement les éléments contenant une sous-chaîne spécifique :

List<String> users = Arrays.asList("tanaka@example.com", "sato@gmail.com", "yamada@yahoo.co.jp");

List<String> gmailUsers = users.stream()
    .filter(email -> email.contains("@gmail.com"))
    .collect(Collectors.toList());

System.out.println(gmailUsers); // [sato@gmail.com]

5-4. Analyse des en-têtes de requêtes HTTP ou des URL

Dans le développement web, le routage ou la gestion spécifique à un appareil peut nécessiter la vérification de sous-chaînes dans l’User-Agent ou l’URL.

String userAgent = "Mozilla/5.0 (iPhone; CPU iPhone OS 16_0 like Mac OS X)";
if (userAgent.contains("iPhone")) {
    System.out.println("スマートフォンからのアクセスです。");
}

5-5. Vérification des chemins de fichiers ou des extensions

Pour déterminer le type d’un fichier en utilisant son chemin :

String filePath = "/usr/local/data/sample.csv";
if (filePath.contains(".csv")) {
    System.out.println("CSVファイルです。");
}

Note : Pour les vérifications d’extension de fichier, endsWith(".csv") est souvent plus précis.

Considérations pratiques

• Appliquez une normalisation (par exemple, toLowerCase(), trim()) lorsque la précision est requise.
• Pour les données à grande échelle, envisagez l’API Stream ou les expressions régulières.
• Rappelez-vous que contains() effectue une correspondance partielle—combinez-la avec d’autres conditions pour une logique plus sûre.

6. Considérations en matière de performances

Bien que la méthode contains() offre une excellente lisibilité et simplicité, vous devez prendre en compte son impact sur les performances lors de la gestion de grands ensembles de données ou d’opérations répétées. Cette section explique le coût de traitement de contains() et des approches alternatives pour une efficacité améliorée.

6-1. Comportement interne et complexité temporelle de contains()

La méthode contains() recherche la sous-chaîne séquentiellement à partir du début dans la chaîne cible. Interne, elle s’appuie sur la méthode indexOf(), et sa complexité temporelle dans le pire des cas est : O(n * m) – n = longueur de la chaîne cible – m = longueur de la chaîne de recherche Exemple de traitement lourd :

for (String line : hugeTextList) {
    if (line.contains("error")) {
        // processing
    }
}

Cela peut affecter significativement les performances lorsqu’il est répété dans de grandes boucles.

6-2. Techniques pour améliorer les performances lors de recherches fréquentes

Lors de l’utilisation répétée de contains() dans de grands ensembles de données, les techniques suivantes peuvent améliorer la vitesse de traitement :

• Convertir toutes les chaînes en minuscules à l’avance

Au lieu d’appeler toLowerCase() lors de chaque comparaison, normalisez les chaînes au préalable :

List<String> normalizedList = originalList.stream()
    .map(String::toLowerCase)
    .collect(Collectors.toList());

• Utiliser l’API Stream avec parallel() pour un traitement parallèle

Utilisez les cœurs du CPU pour accélérer les recherches :

List<String> result = hugeTextList.parallelStream()
    .filter(line -> line.contains("keyword"))
    .collect(Collectors.toList());

• Utiliser des expressions régulières pour les motifs de recherche complexes

Si les conditions sont complexes et peuvent être exprimées en une seule regex, Pattern peut performer mieux :

Pattern pattern = Pattern.compile("error|fail|fatal");
for (String log : logs) {
    if (pattern.matcher(log).find()) {
        // matched
    }
}

6-3. Considérations sur l’Efficacité de la Mémoire et la Réutilisabilité

Les opérations qui convertissent fréquemment les chaînes — telles que toLowerCase() ou substring() — peuvent générer de nombreux objets de chaîne inutiles, affectant l’utilisation de la mémoire. Ceci est particulièrement important pour les applications à longue durée de vie ou le traitement côté serveur. Points clés :

• Éviter de créer des instances de chaîne inutiles.
• Pour les grands ensembles de données, envisager le tamponnage ou le traitement par chunks.
• Mettre en cache les résultats répétés de contains() peut améliorer les performances dans certains cas.

7. Comparaison avec d’Autres Langages de Programmation

La méthode contains() de Java offre une correspondance de sous-chaîne simple et fiable, mais d’autres langages fournissent des fonctionnalités similaires avec leurs propres caractéristiques. Cette section compare la vérification de sous-chaînes en Python, JavaScript et C# pour mettre en évidence les différences et les similitudes.

7-1. Python : Correspondance Partielle Simple avec l’Opérateur in

En Python, vous pouvez vérifier l’inclusion d’une sous-chaîne en utilisant l’opérateur in :

text = "Hello, Python!"
if "Python" in text:
    print("含まれています")

Cette syntaxe est extrêmement lisible — presque comme un langage naturel — et nécessite un apprentissage minimal. Différences et Notes :

• in est un opérateur de langage, pas une méthode.
• Python est également sensible à la casse pour la comparaison de chaînes.
• None produit une exception ; des vérifications de nullité sont requises.

7-2. JavaScript : Correspondance Partielle avec includes()

En JavaScript (ES6+), vous pouvez utiliser la méthode includes() :

const text = "JavaScript is fun";
console.log(text.includes("fun")); // true

Cette méthode est très similaire à contains() de Java et facile à migrer mentalement. Différences et Notes :

• Passer undefined ne lève pas d’exception ; cela retourne simplement false.
• includes() fonctionne également sur les tableaux, augmentant sa polyvalence.

7-3. C# : Contains() Similaire à Java

C# offre également une méthode Contains() avec un comportement similaire à Java :

string text = "Welcome to C#";
bool result = text.Contains("C#");

Différences et Notes :

• Contains() de C# est sensible à la casse par défaut, mais vous pouvez ignorer la casse en utilisant StringComparison.OrdinalIgnoreCase.
• Passer null déclenche ArgumentNullException.

7-4. Tableau de Comparaison Entre les Langages

Résumé : Choisir la Bonne Syntaxe pour Votre Cas d’Utilisation

Bien que la vérification de sous-chaînes soit une exigence courante dans tous les langages, chaque langage fournit sa propre méthode ou syntaxe. contains() de Java offre stabilité et clarté, ce qui le rend bien adapté aux systèmes d’entreprise et aux applications maintenables. Des langages comme Python et JavaScript offrent une syntaxe plus simple et plus concise, idéale pour les scripts légers ou le prototypage rapide. En comprenant à la fois les concepts communs et les fonctionnalités spécifiques de chaque langage, vous pourrez écrire un code plus sûr et plus efficace dans divers langages.

8. Questions Fréquemment Posées (FAQ)

Voici ci-dessous des questions couramment posées concernant la méthode contains() de Java — pour vous aider à comprendre les points délicats et éviter les pièges courants.

Q1. contains() est-il sensible à la casse ?

Oui, il est sensible à la casse. Par exemple, "Java".contains("java") retourne false. Solution :

String input = "Welcome to Java";
boolean result = input.toLowerCase().contains("java");

Q2. Comment puis-je vérifier les correspondances partielles en utilisant des expressions régulières ?

contains() ne prend pas en charge les expressions régulières. Utilisez matches() ou la classe Pattern à la place. Exemple (vérification de motif numérique) :

import java.util.regex.Pattern;
import java.util.regex.Matcher;

String text = "注文番号: A123456";
Pattern pattern = Pattern.compile("A\d+");
Matcher matcher = pattern.matcher(text);

if (matcher.find()) {
    System.out.println("パターンに一致しました。");
}

Q3. Que se passe-t-il si j’appelle contains() sur null ?

Une NullPointerException sera levée.

String target = null;
System.out.println(target.contains("test")); // Error

Solution :

if (target != null && target.contains("test")) {
    System.out.println("含まれています。");
}

Q4. Que se passe-t-il si je passe une chaîne vide («  » » ») à contains() ?

Elle renvoie toujours true.

String text = "Java";
System.out.println(text.contains("")); // true

Bien que cela fasse partie de la spécification officielle, ce comportement est rarement utile et peut entraîner des bugs inattendus si les chaînes vides ne sont pas prévues.

Q5. contains() peut‑il rechercher plusieurs mots‑clés en même temps ?

Non. Chaque appel ne vérifie qu’un seul mot‑clé.

String text = "本日はシステムエラーが発生しました";
if (text.contains("エラー") || text.contains("障害") || text.contains("失敗")) {
    System.out.println("問題が検出されました。");
}

Approche dynamique :

List<String> keywords = Arrays.asList("エラー", "障害", "失敗");
boolean found = keywords.stream().anyMatch(text::contains);

Q6. Quand faut‑il utiliser contains() plutôt que indexOf() ?

contains() renvoie un booléen, tandis que indexOf() renvoie un indice numérique.

• Utilisez contains() lorsque vous voulez simplement savoir si la sous‑chaîne existe.
• Utilisez indexOf() lorsque vous avez également besoin de connaître la position.

  String text = "Error: Disk full";
  if (text.contains("Error")) {
      int pos = text.indexOf("Error");
      System.out.println("Position: " + pos);
  }
  

9. Conclusion

La méthode Java contains() est un outil puissant et pratique pour déterminer si une sous‑chaîne spécifique est contenue dans une chaîne.
Elle est largement utilisée dans de nombreux scénarios tels que la validation d’entrées utilisateur, l’analyse de journaux et le filtrage de données.
Dans cet article, nous avons couvert :

• Syntaxe de base et valeurs de retour
• Sensibilité à la casse et comment la gérer
• Gestion des nulls et des chaînes vides
• Différences avec d’autres méthodes de comparaison de chaînes
• Cas d’utilisation pratiques : validation, recherche dans les logs, traitement de flux
• Considérations de performance et techniques d’optimisation
• Comparaison avec Python, JavaScript et C#
• FAQ et astuces de dépannage

Bien que contains() soit intuitif et polyvalent, son utilisation doit être évaluée avec soin dans les cas impliquant de grands ensembles de données, des appels fréquents ou des conditions de recherche complexes.
En combinant normalisation, traitement parallèle, expressions régulières et stratégies de mise en cache, vous pouvez conserver à la fois les performances et la lisibilité.
Puisque contains() est fondamental pour travailler avec les chaînes en Java, nous espérons que cet article vous aidera à l’utiliser de manière plus sûre et efficace dans vos projets de développement.