En Java, Comment puis-je vérifier si une chaîne de caractères contient une sous-chaîne (ignoring case)? [dupliquer]

et 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.*");

si vous êtes en mesure d'utiliser org.Apache.commun.lang.StringUtils , je suggère d'utiliser ce qui suit:

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

vous pouvez utiliser la méthode toLowerCase() :

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() )
}

alors 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. Puis, quand quelqu'un fait remarquer que vous devez utiliser contains au lieu de indexOf , vous n'avez qu'une seule ligne de code à modifier.

je suis également favorable à la solution RegEx. Le code sera beaucoup plus propre. J'hésiterais à utiliser toLowerCase () dans des situations où je savais que les cordes seraient grandes, puisque les cordes sont immuables et devraient être copiées. De plus, la solution matches() peut être déroutante car elle prend une expression régulière comme argument (la recherche de "Need$le" est problématique).

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 + "." );
}

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

les solutions critiques en matière de vitesse pourraient inclure l'itération du caractère haystack par le caractère à la recherche du premier caractère de l'aiguille. Lorsque le premier caractère est apparié (cas insensivement), commencer itérer à travers l'aiguille caractère par caractère, à la recherche du caractère correspondant dans le botte de foin et renvoie "true" si tous les caractères sont accompagnés. Si un caractère non-apparié est rencontré, reprendre l'itération à travers la botte de foin au caractère suivant, en retournant "false" si une position > botte de foin.length() - aiguille.longueur() est atteint.

j'utiliserais une combinaison de la méthode contains et de la méthode toUpper qui font 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()));

Ce sera de retour:

Search1=true

Search2=false