posicion - extraer caracteres de una cadena java

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

Question

Esta pregunta ya tiene una respuesta aquí:

• ¿Cómo verificar si una cadena contiene otra cadena de una manera que no distingue mayúsculas y minúsculas en Java? 17 respuestas

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

Answer 1

¿Qué hay de los 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 2

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

Entonces 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 le señala que debe usar el contains lugar de indexOf , solo tiene que cambiar una línea de código.

Answer 3

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

Answer 4

También estoy a favor de la solución RegEx. El código será mucho más limpio. No dudaría en usar toLowerCase () en situaciones en las que sabía que las cadenas serían grandes, ya que las cadenas son inmutables y deberían copiarse. Además, la solución de coincidencias () puede ser confusa porque toma una expresión regular como argumento (la búsqueda de "Need $ le" cold be problematic).

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 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 la especificación de Java para cadenas).

Las soluciones de velocidad crítica podrían incluir la iteración a través del personaje del pajar por personaje buscando el primer carácter de la aguja. Cuando el primer carácter coincida (caso de manera insostenida), comience a iterar a través del carácter de la aguja por carácter, buscando el carácter correspondiente en el pajar y devolviendo "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 ().

Answer 5

toUpper una combinación del método contiene y el método toUpper que forman parte de la clase String. A continuación se muestra un ejemplo:

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 = true
Search2 = falso

Answer 6

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