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

J’ai deux Ssortingng s, str1 et str2 . Comment vérifier si str2 est contenu dans str1 , en ignorant la casse?

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

Qu’en est-il des matches() ?

 Ssortingng ssortingng = "Madam, I am Adam"; // Starts with boolean b = ssortingng.startsWith("Mad"); // true // Ends with b = ssortingng.endsWith("dam"); // true // Anywhere b = ssortingng.indexOf("I am") >= 0; // true // To ignore case, regular expressions must be used // Starts with b = ssortingng.matches("(?i)mad.*"); // Ends with b = ssortingng.matches("(?i).*adam"); // Anywhere b = ssortingng.matches("(?i).*i am.*"); 

Si vous pouvez utiliser org.apache.commons.lang.SsortingngUtils , je suggère d’utiliser les éléments suivants:

 Ssortingng container = "aBcDeFg"; Ssortingng content = "dE"; boolean containerContainsContent = SsortingngUtils.containsIgnoreCase(container, content); 

Vous pouvez utiliser la méthode toLowerCase() :

 public boolean contains( Ssortingng haystack, Ssortingng 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, lorsque quelqu’un indique que vous devez utiliser contains au lieu de indexOf , vous n’avez qu’une seule ligne de code à modifier.

Je privilégie é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, car 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 comme argument (la recherche de “Need $ le” est problématique).

S’appuyant sur certains des exemples ci-dessus:

 public boolean containsIgnoreCase( Ssortingng haystack, Ssortingng needle ) { if(needle.equals("")) return true; if(haystack == null || needle == null || haystack .equals("")) return false; Pattern p = Pattern.comstack(needle,Pattern.CASE_INSENSITIVE+Pattern.LITERAL); Matcher m = p.matcher(haystack); return m.find(); } example call: Ssortingng needle = "Need$le"; Ssortingng 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 pourriez vouloir gérer les chaînes NULL et vides différemment en fonction de vos besoins. Je pense qu’elles sont plus proches des spécifications Java pour les chaînes.)

Les solutions critiques de vitesse pourraient inclure une itération dans le caractère de botte de foin par caractère à la recherche du premier caractère de l’aiguille. Lorsque le premier caractère est apparié (insensiblement à la casse), commencez à parcourir le caractère de l’aiguille par caractère, à la recherche du caractère correspondant dans la botte de foin et en renvoyant “true” si tous les caractères sont identiques. Si un caractère non apparié est rencontré, reprenez l’itération à travers le haystack au caractère suivant, en retournant “false” si une position> haystack.length () – needle.length () est atteinte.

J’utiliserais une combinaison de la méthode contains et de la méthode toUpper qui font partie de la classe Ssortingng. Un exemple est ci-dessous:

 Ssortingng ssortingng1 = "AAABBBCCC"; Ssortingng ssortingng2 = "DDDEEEFFF"; Ssortingng searchForThis = "AABB"; System.out.println("Search1="+ssortingng1.toUpperCase().contains(searchForThis.toUpperCase())); System.out.println("Search2="+ssortingng2.toUpperCase().contains(searchForThis.toUpperCase())); 

Cela va retourner:

Search1 = true
Search2 = false