java - La cadena contiene-ignora el caso

string contains

Question

Esta pregunta ya tiene una respuesta aquí:

• ¿Cómo verificar si una Cadena contiene otra Cadena de manera insensible a mayúsculas / minúsculas en Java? 17 respuestas

¿Es posible determinar si String str1="ABCDEFGHIJKLMNOP" contiene un patrón de cadena strptrn="gHi" ? Quería saber si eso es posible cuando los personajes no distinguen entre mayúsculas y minúsculas. ¿Si es así, cómo?

Answer 1

Prueba esto

public static void main(String[] args)
{

    String original = "ABCDEFGHIJKLMNOPQ";
    String tobeChecked = "GHi";

    System.out.println(containsString(original, tobeChecked, true));        
    System.out.println(containsString(original, tobeChecked, false));

}

public static boolean containsString(String original, String tobeChecked, boolean caseSensitive)
{
    if (caseSensitive)
    {
        return original.contains(tobeChecked);

    }
    else
    {
        return original.toLowerCase().contains(tobeChecked.toLowerCase());
    }

}

Answer 2

Puede usar java.util.regex.Pattern con el indicador CASE_INSENSITIVE para la coincidencia insensible a mayúsculas y minúsculas:

Pattern.compile(Pattern.quote(strptrn), Pattern.CASE_INSENSITIVE).matcher(str1).find();

Answer 3

Puedes usar

org.apache.commons.lang3.StringUtils.containsIgnoreCase(CharSequence str,
                                     CharSequence searchStr);

Comprueba si CharSequence contiene una búsqueda CharSequence independientemente del caso, manejando nulo. La insensibilidad a mayúsculas y minúsculas se define como String.equalsIgnoreCase (String).

Una CharSequence nula devolverá falsa.

Este será mejor que regex ya que la expresión regular siempre es costosa en términos de rendimiento.

Para el documento oficial, consulte: StringUtils.containsIgnoreCase

Actualización:

Si estás entre los que

• no quiero usar la biblioteca de Apache commons
• no quiero ir con las costosas soluciones basadas en regex/Pattern ,
• no desea crear un objeto de cadena adicional usando toLowerCase ,

puede implementar su propio containsIgnoreCase personalizado usando java.lang.String.regionMatches

public boolean regionMatches(boolean ignoreCase,
                             int toffset,
                             String other,
                             int ooffset,
                             int len)

ignoreCase : si es verdadero, ignora el caso al comparar caracteres.

public static boolean containsIgnoreCase(String str, String searchStr)     {
    if(str == null || searchStr == null) return false;

    final int length = searchStr.length();
    if (length == 0)
        return true;

    for (int i = str.length() - length; i >= 0; i--) {
        if (str.regionMatches(true, i, searchStr, 0, length))
            return true;
    }
    return false;
}

Answer 4

Si no vas con expresiones regulares:

"ABCDEFGHIJKLMNOP".toLowerCase().contains("gHi".toLowerCase())

Answer 5

Una versión optimizada de Imran Tariq

Pattern.compile(strptrn, Pattern.CASE_INSENSITIVE + Pattern.LITERAL).matcher(str1).find();

Pattern.quote (strptrn) siempre devuelve "/ Q" + s + "/ E" incluso si no hay nada que citar, la concatinación arruina el rendimiento.