Question En Java, comment vérifier si une chaîne contient une sous-chaîne (cas ignorant)? [dupliquer]


Cette question a déjà une réponse ici:

j'en ai deux Strings, str1 et str2. Comment puis-je vérifier si str2 est contenu dans str1, en ignorant le cas?


460
2018-02-16 17:45


origine


Réponses:


str1.toLowerCase().contains(str2.toLowerCase())

933
2018-02-16 17:49



Que diriez-vous matches()?

String string = "Madam, I am Adam";

// Starts with
boolean  b = string.startsWith("Mad");  // true

// Ends with
b = string.endsWith("dam");             // true

// Anywhere
b = string.indexOf("I am") >= 0;        // true

// To ignore case, regular expressions must be used

// Starts with
b = string.matches("(?i)mad.*");

// Ends with
b = string.matches("(?i).*adam");

// Anywhere
b = string.matches("(?i).*i am.*");

119
2018-04-10 17:17



Si vous êtes capable d'utiliser org.apache.commons.lang.StringUtils, Je suggère d'utiliser ce qui suit:

String container = "aBcDeFg";
String content = "dE";
boolean containerContainsContent = StringUtils.containsIgnoreCase(container, content);

29
2018-05-05 15:20



Vous pouvez utiliser le toLowerCase() méthode:

public boolean contains( String haystack, String needle ) {
  haystack = haystack == null ? "" : haystack;
  needle = needle == null ? "" : needle;

  // Works, but is not the best.
  //return haystack.toLowerCase().indexOf( needle.toLowerCase() ) > -1

  return haystack.toLowerCase().contains( needle.toLowerCase() )
}

Puis appelez-le en utilisant:

if( contains( str1, str2 ) ) {
  System.out.println( "Found " + str2 + " within " + str1 + "." );
}

Notez qu'en créant votre propre méthode, vous pouvez la réutiliser. Ensuite, quand quelqu'un indique que vous devez utiliser contains au lieu de indexOf, vous n'avez qu'une seule ligne de code à modifier.


20
2018-02-16 17:48



Je favorise également la solution RegEx. Le code sera beaucoup plus propre. J'hésiterais à utiliser toLowerCase () dans des situations où je savais que les chaînes allaient être grandes, puisque les chaînes sont immuables et devraient être copiées. En outre, la solution matches () peut être source de confusion car elle prend une expression régulière en argument (la recherche de "Need $ le" peut être problématique).

En s'appuyant sur certains des exemples ci-dessus:

public boolean containsIgnoreCase( String haystack, String needle ) {
  if(needle.equals(""))
    return true;
  if(haystack == null || needle == null || haystack .equals(""))
    return false; 

  Pattern p = Pattern.compile(needle,Pattern.CASE_INSENSITIVE+Pattern.LITERAL);
  Matcher m = p.matcher(haystack);
  return m.find();
}

example call: 

String needle = "Need$le";
String haystack = "This is a haystack that might have a need$le in it.";
if( containsIgnoreCase( haystack, needle) ) {
  System.out.println( "Found " + needle + " within " + haystack + "." );
}

(Remarque: vous pouvez gérer les chaînes NULL et les chaînes vides différemment selon vos besoins.) Je pense que la façon dont je l'ai est plus proche de la spécification Java pour les chaînes.)

Les solutions critiques de vitesse peuvent inclure l'itération à travers le caractère haystack par caractère en recherchant le premier caractère de l'aiguille. Lorsque le premier caractère est apparié (insensible à la casse), commencez à parcourir le caractère aiguille par caractère, en cherchant le caractère correspondant dans la botte de foin et en retournant «vrai» si tous les caractères sont appariés. Si un caractère non-apparié est rencontré, reprendre l'itération à travers le haystack au caractère suivant, en retournant "false" si une position> haystack.length ()-needle.length () est atteinte.


9
2017-12-30 23:23



J'utiliserais une combinaison de la méthode contient et de la toUpper méthode faisant partie de la classe String. Un exemple est ci-dessous:

String string1 = "AAABBBCCC"; 
String string2 = "DDDEEEFFF";
String searchForThis = "AABB";

System.out.println("Search1="+string1.toUpperCase().contains(searchForThis.toUpperCase()));

System.out.println("Search2="+string2.toUpperCase().contains(searchForThis.toUpperCase()));

Cela reviendra:

Search1 = true
      Search2 = false


6
2018-02-16 17:55