¿Cómo verificar si una Cadena contiene otra Cadena en mayúsculas y minúsculas en Java?

Digamos que tengo dos cuerdas

String s1 = "AbBaCca";
String s2 = "bac";

Quiero realizar una comprobación de devolución que s2está contenida dentro s1. Puedo hacer esto con:

return s1.contains(s2);

Estoy bastante seguro de que contains()distingue entre mayúsculas y minúsculas, sin embargo, no puedo determinar esto con seguridad leyendo la documentación. Si es así, supongo que mi mejor método sería algo como:

return s1.toLowerCase().contains(s2.toLowerCase());

Dejando de lado todo esto, ¿hay otra manera (posiblemente mejor) de lograr esto sin preocuparse por la sensibilidad a mayúsculas y minúsculas?

Sí, contiene mayúsculas y minúsculas. Puede usar java.util.regex.Pattern con el indicador CASE_INSENSITIVE para la coincidencia entre mayúsculas y minúsculas:

Pattern.compile(Pattern.quote(wantedStr), Pattern.CASE_INSENSITIVE).matcher(source).find();

EDITAR: si s2 contiene caracteres especiales regex (de los cuales hay muchos), es importante citarlo primero. He corregido mi respuesta, ya que es la primera que verán las personas, pero vote por la de Matt Quail desde que señaló esto.

Un problema con la respuesta de Dave L. es cuando s2 contiene marcas de expresiones regulares como \d, etc.

Desea llamar a Pattern.quote () en s2:

Pattern.compile(Pattern.quote(s2), Pattern.CASE_INSENSITIVE).matcher(s1).find();

Puedes usar

org.apache.commons.lang3.StringUtils.containsIgnoreCase("AbBaCca", "bac");

La biblioteca Apache Commons es muy útil para este tipo de cosas. Y esta en particular puede ser mejor que las expresiones regulares, ya que la expresión regular siempre es costosa en términos de rendimiento.

Una implementación más rápida: utilización String.regionMatches()

Usar regexp puede ser relativamente lento. (Ser lento) no importa si solo quieres verificar en un caso. Pero si tiene una matriz o una colección de miles o cientos de miles de cadenas, las cosas pueden volverse bastante lentas.

La solución presentada a continuación no usa expresiones regulares ni toLowerCase() (que también es lenta porque crea otras cadenas y las tira después de la comprobación).

La solución se basa en el método String.regionMatches () que parece ser desconocido. Comprueba si 2 Stringregiones coinciden, pero lo importante es que también tiene una sobrecarga con un ignoreCaseparámetro útil .

public static boolean containsIgnoreCase(String src, String what) {
    final int length = what.length();
    if (length == 0)
        return true; // Empty string is contained

    final char firstLo = Character.toLowerCase(what.charAt(0));
    final char firstUp = Character.toUpperCase(what.charAt(0));

    for (int i = src.length() - length; i >= 0; i--) {
        // Quick check before calling the more expensive regionMatches() method:
        final char ch = src.charAt(i);
        if (ch != firstLo && ch != firstUp)
            continue;

        if (src.regionMatches(true, i, what, 0, length))
            return true;
    }

    return false;
}

Análisis de velocidad

Este análisis de velocidad no significa ser ciencia de cohetes, solo una imagen aproximada de lo rápido que son los diferentes métodos.

Comparo 5 métodos.

1. Nuestro contieneIgnoreCase () método .
2. Al convertir ambas cadenas a minúsculas y llamar String.contains() .
3. Al convertir la cadena de origen en minúsculas y llamar String.contains() con la subcadena pre-almacenada en caché y en minúsculas. Esta solución ya no es tan flexible porque prueba una subcadena predefinida.
4. Usando expresión regular (la respuesta aceptada Pattern.compile().matcher().find()...)
5. Usando expresiones regulares pero con pre-creado y almacenado en caché Pattern. Esta solución ya no es tan flexible porque prueba una subcadena predefinida.

Resultados (llamando al método 10 millones de veces):

1. Nuestro método: 670 ms
2. 2x toLowerCase () y contiene (): 2829 ms
3. 1x toLowerCase () y contiene () con subcadena en caché: 2446 ms
4. Regexp: 7180 ms
5. Regexp con caché Pattern: 1845 ms

Resultados en una tabla:

                                            RELATIVE SPEED   1/RELATIVE SPEED
 METHOD                          EXEC TIME    TO SLOWEST      TO FASTEST (#1)
------------------------------------------------------------------------------
 1. Using regionMatches()          670 ms       10.7x            1.0x
 2. 2x lowercase+contains         2829 ms        2.5x            4.2x
 3. 1x lowercase+contains cache   2446 ms        2.9x            3.7x
 4. Regexp                        7180 ms        1.0x           10.7x
 5. Regexp+cached pattern         1845 ms        3.9x            2.8x

Nuestro método es 4 veces más rápido en comparación con las minúsculas y el uso contains(), 10 veces más rápido en comparación con el uso de expresiones regulares y también 3 veces más rápido incluso si Patternestá pre-almacenado en caché (y pierde la flexibilidad de verificar una subcadena arbitraria).

Código de prueba de análisis

Si está interesado en cómo se realizó el análisis, aquí está la aplicación completa ejecutable:

import java.util.regex.Pattern;

public class ContainsAnalysis {

    // Case 1 utilizing String.regionMatches()
    public static boolean containsIgnoreCase(String src, String what) {
        final int length = what.length();
        if (length == 0)
            return true; // Empty string is contained

        final char firstLo = Character.toLowerCase(what.charAt(0));
        final char firstUp = Character.toUpperCase(what.charAt(0));

        for (int i = src.length() - length; i >= 0; i--) {
            // Quick check before calling the more expensive regionMatches()
            // method:
            final char ch = src.charAt(i);
            if (ch != firstLo && ch != firstUp)
                continue;

            if (src.regionMatches(true, i, what, 0, length))
                return true;
        }

        return false;
    }

    // Case 2 with 2x toLowerCase() and contains()
    public static boolean containsConverting(String src, String what) {
        return src.toLowerCase().contains(what.toLowerCase());
    }

    // The cached substring for case 3
    private static final String S = "i am".toLowerCase();

    // Case 3 with pre-cached substring and 1x toLowerCase() and contains()
    public static boolean containsConverting(String src) {
        return src.toLowerCase().contains(S);
    }

    // Case 4 with regexp
    public static boolean containsIgnoreCaseRegexp(String src, String what) {
        return Pattern.compile(Pattern.quote(what), Pattern.CASE_INSENSITIVE)
                    .matcher(src).find();
    }

    // The cached pattern for case 5
    private static final Pattern P = Pattern.compile(
            Pattern.quote("i am"), Pattern.CASE_INSENSITIVE);

    // Case 5 with pre-cached Pattern
    public static boolean containsIgnoreCaseRegexp(String src) {
        return P.matcher(src).find();
    }

    // Main method: perfroms speed analysis on different contains methods
    // (case ignored)
    public static void main(String[] args) throws Exception {
        final String src = "Hi, I am Adam";
        final String what = "i am";

        long start, end;
        final int N = 10_000_000;

        start = System.nanoTime();
        for (int i = 0; i < N; i++)
            containsIgnoreCase(src, what);
        end = System.nanoTime();
        System.out.println("Case 1 took " + ((end - start) / 1000000) + "ms");

        start = System.nanoTime();
        for (int i = 0; i < N; i++)
            containsConverting(src, what);
        end = System.nanoTime();
        System.out.println("Case 2 took " + ((end - start) / 1000000) + "ms");

        start = System.nanoTime();
        for (int i = 0; i < N; i++)
            containsConverting(src);
        end = System.nanoTime();
        System.out.println("Case 3 took " + ((end - start) / 1000000) + "ms");

        start = System.nanoTime();
        for (int i = 0; i < N; i++)
            containsIgnoreCaseRegexp(src, what);
        end = System.nanoTime();
        System.out.println("Case 4 took " + ((end - start) / 1000000) + "ms");

        start = System.nanoTime();
        for (int i = 0; i < N; i++)
            containsIgnoreCaseRegexp(src);
        end = System.nanoTime();
        System.out.println("Case 5 took " + ((end - start) / 1000000) + "ms");
    }

}

Una forma más simple de hacer esto (sin preocuparse por la coincidencia de patrones) sería convertir ambos Strings en minúsculas:

String foobar = "fooBar";
String bar = "FOO";
if (foobar.toLowerCase().contains(bar.toLowerCase()) {
    System.out.println("It's a match!");
}

Sí, esto se puede lograr:

String s1 = "abBaCca";
String s2 = "bac";

String s1Lower = s1;

//s1Lower is exact same string, now convert it to lowercase, I left the s1 intact for print purposes if needed

s1Lower = s1Lower.toLowerCase();

String trueStatement = "FALSE!";
if (s1Lower.contains(s2)) {

    //THIS statement will be TRUE
    trueStatement = "TRUE!"
}

return trueStatement;

Este código devolverá la cadena "¡VERDADERO!" ya que descubrió que tus personajes estaban contenidos.

Puede usar expresiones regulares , y funciona:

boolean found = s1.matches("(?i).*" + s2+ ".*");

Aquí hay algunos compatibles con Unicode que puede hacer si tira de ICU4j. Supongo que "ignorar mayúsculas y minúsculas" es cuestionable para los nombres de métodos porque, aunque las comparaciones de fuerza primarias ignoran mayúsculas y minúsculas, se describen como los detalles que dependen de la configuración regional. Pero es de esperar que dependa de la ubicación de una manera que el usuario esperaría.

public static boolean containsIgnoreCase(String haystack, String needle) {
    return indexOfIgnoreCase(haystack, needle) >= 0;
}

public static int indexOfIgnoreCase(String haystack, String needle) {
    StringSearch stringSearch = new StringSearch(needle, haystack);
    stringSearch.getCollator().setStrength(Collator.PRIMARY);
    return stringSearch.first();
}

Hice una prueba para encontrar una coincidencia entre mayúsculas y minúsculas de una cadena. Tengo un Vector de 150,000 objetos, todos con una Cadena como un solo campo y quería encontrar el subconjunto que coincidía con una cadena. Probé tres métodos:

1. Convertir todo a minúsculas

   for (SongInformation song: songs) {
       if (song.artist.toLowerCase().indexOf(pattern.toLowercase() > -1) {
               ...
       }
   }

2. Use el método String coincide con ()

   for (SongInformation song: songs) {
       if (song.artist.matches("(?i).*" + pattern + ".*")) {
       ...
       }
   }

3. Usa expresiones regulares

   Pattern p = Pattern.compile(pattern, Pattern.CASE_INSENSITIVE);
   Matcher m = p.matcher("");
   for (SongInformation song: songs) {
       m.reset(song.artist);
       if (m.find()) {
       ...
       }
   }

Los resultados del tiempo son:

• Sin intento de coincidencia: 20 ms

• Para reducir la coincidencia: 182 ms

• Cadenas: 278 ms.

• Expresión regular: 65 ms.

La expresión regular parece ser la más rápida para este caso de uso.

Hay una manera simple y concisa, utilizando la bandera regex (mayúsculas y minúsculas {i}):

 String s1 = "hello abc efg";
 String s2 = "ABC";
 s1.matches(".*(?i)"+s2+".*");

/*
 * .*  denotes every character except line break
 * (?i) denotes case insensitivity flag enabled for s2 (String)
 * */

No estoy seguro de cuál es su pregunta principal aquí, pero sí, .contains distingue mayúsculas de minúsculas.

String container = " Case SeNsitive ";
String sub = "sen";
if (rcontains(container, sub)) {
    System.out.println("no case");
}

public static Boolean rcontains(String container, String sub) {

    Boolean b = false;
    for (int a = 0; a < container.length() - sub.length() + 1; a++) {
        //System.out.println(sub + " to " + container.substring(a, a+sub.length()));
        if (sub.equalsIgnoreCase(container.substring(a, a + sub.length()))) {
            b = true;
        }
    }
    return b;
}

Básicamente, es un método que toma dos cadenas. Se supone que es una versión sin distinción entre mayúsculas y minúsculas de contiene (). Cuando se utiliza el método contiene, desea ver si una cadena está contenida en la otra.

Este método toma la cadena que es "sub" y comprueba si es igual a las subcadenas de la cadena de contenedor que tienen la misma longitud que la "sub". Si observa el forbucle, verá que itera en subcadenas (que son la longitud del "sub") sobre la cadena del contenedor.

Cada iteración verifica si la subcadena de la cadena del contenedor está equalsIgnoreCaseen la sub.

Si tiene que buscar una cadena ASCII en otra cadena ASCII, como una URL , encontrará que mi solución es mejor. He probado el método de icza y el mío para la velocidad y aquí están los resultados:

• El caso 1 tomó 2788 ms - regionMatches
• El caso 2 tomó 1520 ms - mi

El código:

public static String lowerCaseAscii(String s) {
    if (s == null)
        return null;

    int len = s.length();
    char[] buf = new char[len];
    s.getChars(0, len, buf, 0);
    for (int i=0; i<len; i++) {
        if (buf[i] >= 'A' && buf[i] <= 'Z')
            buf[i] += 0x20;
    }

    return new String(buf);
}

public static boolean containsIgnoreCaseAscii(String str, String searchStr) {
    return StringUtils.contains(lowerCaseAscii(str), lowerCaseAscii(searchStr));
}

import java.text.Normalizer;

import org.apache.commons.lang3.StringUtils;

public class ContainsIgnoreCase {

    public static void main(String[] args) {

        String in = "   Annulée ";
        String key = "annulee";

        // 100% java
        if (Normalizer.normalize(in, Normalizer.Form.NFD).replaceAll("[\\p{InCombiningDiacriticalMarks}]", "").toLowerCase().contains(key)) {
            System.out.println("OK");
        } else {
            System.out.println("KO");
        }

        // use commons.lang lib
        if (StringUtils.containsIgnoreCase(Normalizer.normalize(in, Normalizer.Form.NFD).replaceAll("[\\p{InCombiningDiacriticalMarks}]", ""), key)) {
            System.out.println("OK");
        } else {
            System.out.println("KO");
        }

    }

}

"AbCd".toLowerCase().contains("abcD".toLowerCase())

Podemos usar stream con anyMatch y contiene Java 8

public class Test2 {
    public static void main(String[] args) {

        String a = "Gina Gini Protijayi Soudipta";
        String b = "Gini";

        System.out.println(WordPresentOrNot(a, b));
    }// main

    private static boolean WordPresentOrNot(String a, String b) {
    //contains is case sensitive. That's why change it to upper or lower case. Then check
        // Here we are using stream with anyMatch
        boolean match = Arrays.stream(a.toLowerCase().split(" ")).anyMatch(b.toLowerCase()::contains);
        return match;
    }

}

o puede usar un enfoque simple y simplemente convertir el caso de la cadena en el caso de la subcadena y luego usar el método contiene.

String x="abCd";
System.out.println(Pattern.compile("c",Pattern.CASE_INSENSITIVE).matcher(x).find());

Simplemente podrías hacer algo como esto:

String s1 = "AbBaCca";
String s2 = "bac";
String toLower = s1.toLowerCase();
return toLower.contains(s2);