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

Question

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

Answer 1

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

Answer 2

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

Entonces llaman usando:

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

en cuenta que mediante la creación de su propio método, se puede reutilizar. Luego, cuando alguien le indique que debe usar contains en lugar de indexOf, solo tiene una línea de código para cambiar.

Answer 3

que haría uso de una combinación del método contains y el método toUpper que forman parte de la clase String. Un ejemplo es el siguiente:

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 devolverá:

Search1 = true
Search2 = false

Answer 4

¿Qué tal 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 5

Si usted es capaz de utilizar org.apache.commons.lang.StringUtils, se sugiere emplear el siguiente:

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

Answer 6

también estoy a favor de la solución de expresiones regulares. 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).

Sobre la base de 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 para manejar cadenas NULL y vacíos de forma diferente en función de sus necesidades Creo que como yo tienen que está más cerca de la especificación de Java para cadenas.)

Las soluciones de velocidad crítica podrían incluir iterar a través del carácter de pajar por carácter 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().