En Java, comment faire pour vérifier si une chaîne contient une sous-chaîne (ignorant la casse) ?

Question

J’ai deux s : et . Comment vérifier si est contenue dans `` , indépendamment de la casse ?

Answer 1

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

Answer 2

Que diriez-vous de 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.*");
 

Answer 3

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);
 

Answer 4

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

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 fait remarquer que vous devriez utiliser contains au lieu de indexOf , vous n'avez qu'une seule ligne de code à changer.

Answer 5

Je suis également favorable à l'expression régulière de la solution. Le code sera beaucoup plus propre. Je n'hésiterais pas à utiliser toLowerCase() dans des situations où je savais que les chaînes allaient être grands, car les chaînes sont immuables et ne pourrait être copié. Aussi, les matches() solution pourrait être source de confusion car il prend une expression régulière comme un argument (de la recherche pour "Need$le" froid être 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 souhaitez peut-être gérer la valeur NULL et des chaînes vides différemment en fonction de vos besoins. Je pense que la façon que je l'ai elle est plus proche du Java spec pour les chaînes de caractères.)

Vitesse critique solutions pourraient inclure une itération dans la botte de foin, caractère par caractère à la recherche pour le premier caractère de l'aiguille. Lorsque le premier caractère est adapté (cas insenstively), commencer une itération à travers l'aiguille, caractère par caractère, à la recherche pour le caractère correspondant dans la botte de foin et renvoie "true" si tous les caractères sont accompagnés. Si une non-correspondance de caractère est rencontré, reprendre itération de la botte de foin au caractère suivant, le retour "false" si une position > botte de foin.length() - aiguille.longueur() est atteint.