En Java, ¿cómo puedo verificar si una cadena contiene una subcadena (ignorando el caso)?

Tengo dos String , str1 y str2 . ¿Cómo puedo verificar si str2 está contenido dentro de str1 , ignorando el caso?

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

¿Qué hay de las 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 puede usar org.apache.commons.lang.StringUtils , le sugiero que use lo siguiente:

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

Puede usar el método 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() ) } 

Luego llámalo usando:

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

Tenga en cuenta que al crear su propio método, puede reutilizarlo. Luego, cuando alguien señala que debe usar contains lugar de indexOf , solo tiene una línea de código para cambiar.

También estoy a favor de la solución RegEx. El código será mucho más limpio. Yo dudaría en usar toLowerCase () en situaciones donde sabía que las cadenas iban a ser grandes, ya que las cadenas son inmutables y tendrían que ser copiadas. Además, la solución de matches () puede ser confusa porque toma una expresión regular como argumento (la búsqueda de “Need $ le” puede ser problemática).

Basándose en algunos de los ejemplos anteriores:

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

(Nota: es posible que desee manejar cadenas NULL y vacías de manera diferente según sus necesidades. Creo que la forma en que lo tengo está más cerca de las especificaciones de Java para cadenas).

Las soluciones críticas de velocidad podrían incluir iterar a través del personaje del pajar buscando el primer carácter de la aguja. Cuando el primer personaje coincida (caso insensato), comience a recorrer la aguja carácter por carácter, busque el carácter correspondiente en el pajar y devuelva “verdadero” si todos los caracteres coinciden. Si se encuentra un carácter no coincidente, reanude la iteración a través del pajar en el siguiente carácter, devolviendo “falso” si se alcanza una posición> haystack.length () – needle.length ().

toUpper una combinación del método contains y el método toUpper que son parte de la clase String. Un ejemplo es a continuación:

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

Esto volverá:

Search1 = verdadero
Search2 = falso