Correspondance de chaînes insensible à la casse en Java

1. Vue d'ensemble

Il existe de nombreuses façons de vérifier si une chaîne contient une sous-chaîne. Dans cet article, nous rechercherons des sous-chaînes dans une chaîne tout en nous concentrant sur les solutions de contournement insensibles à la casse pour String.contains () en Java. Plus important encore, nous fournirons des exemples de résolution de ce problème.

2. La solution la plus simple: String.toLowerCase

La solution la plus simple consiste à utiliser String.toLowerCase () . Dans ce cas, nous allons transformer les deux chaînes en minuscules, puis utiliser la méthode contains () :

assertTrue(src.toLowerCase().contains(dest.toLowerCase()));

Nous pouvons également utiliser String.toUpperCase () et cela fournirait le même résultat.

3. Correspondances de chaînes avec des expressions régulières

Une autre option consiste à utiliser String.matches () avec des expressions régulières:

assertTrue(src.matches("(?i).*" + dest + ".*"));

La méthode matches () prend un tring S pour représenter l'expression régulière. (? i) active l' insensibilité à la casse et . * utilise tous les caractères sauf les sauts de ligne.

4. String.regionMatches

Nous pouvons également utiliser String.regionMatches () . Il vérifie si deux régions String correspondent, en utilisant true pour le paramètre ignoreCase :

public static boolean processRegionMatches(String src, String dest) { for (int i = src.length() - dest.length(); i >= 0; i--) if (src.regionMatches(true, i, dest, 0, dest.length())) return true; return false; }
assertTrue(processRegionMatches(src, dest));

Pour améliorer les performances, il commence à faire correspondre la région, en tenant compte de la longueur de la chaîne de destination . Ensuite, cela diminue l'itérateur.

5. Modèle avec l' option CASE_INSENSITIVE

La classe java.util.regex.Pattern nous fournit un moyen de faire correspondre des chaînes en utilisant la méthode matcher () . Dans ce cas, nous pouvons utiliser la méthode quote () pour échapper tous les caractères spéciaux et le drapeau CASE_INSENSITIVE . Nous allons jeter un coup d'oeil:

assertTrue(Pattern.compile(Pattern.quote(dest), Pattern.CASE_INSENSITIVE) .matcher(src) .find());

6. Apache Commons StringUtils.containsIgnoreCase

Enfin, nous allons profiter de la classe Apache Commons StringUtils :

assertTrue(StringUtils.containsIgnoreCase(src, dest));

7. Comparaison des performances

Comme dans cet article général sur la vérification des sous-chaînes à l'aide de la méthode contains , nous avons utilisé le framework open-source Java Microbenchmark Harness (JMH) pour comparer les performances des méthodes en nanosecondes :

  1. Modèle CASE_INSENSITIVE Expression régulière : 399,387 ns
  2. Chaîne toLowerCase : 434,064 ns
  3. Apache Commons StringUtils : 496,313 ns
  4. Correspondances de région de chaîne : 718,842 ns
  5. Correspondances de chaîne avec une expression régulière : 3964,346 ns

Comme nous pouvons le voir, le gagnant est Pattern avec le drapeau CASE_INSENSITIVE activé, suivi de près par toLowerCase () . Nous avons également remarqué une nette amélioration des performances entre Java 8 et Java 11.

8. Conclusion

Dans ce didacticiel, nous avons examiné différentes façons de vérifier une chaîne pour une sous-chaîne, tout en ignorant la casse en Java.

Nous avons examiné l'utilisation de String.toLowerCase () et toUpperCase () , String.matches () , String.regionMatches () , Apache Commons StringUtils.containsIgnoreCase () et Pattern.matcher (). Find () .

De plus, nous avons évalué les performances de chaque solution et constaté que l'utilisation de la méthode compile () de java.util.regex.Pattern avec l' indicateur CASE_INSENSITIVE fonctionnait le mieux .

Comme toujours, le code est disponible sur sur GitHub.