Como verificar se uma String contém outra String de uma maneira que não diferencia maiúsculas de minúsculas em Java?

Digamos que eu tenho duas cordas,

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

Quero executar uma verificação de retorno que s2esteja contida nele s1. Eu posso fazer isso com:

return s1.contains(s2);

Tenho certeza de que contains()diferencia maiúsculas de minúsculas, mas não posso determinar isso com certeza lendo a documentação. Se for, acho que meu melhor método seria algo como:

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

Tudo isso à parte, existe outra maneira (possivelmente melhor) de fazer isso sem se preocupar com a distinção entre maiúsculas e minúsculas?

Sim, contém diferencia maiúsculas de minúsculas. Você pode usar java.util.regex.Pattern com o sinalizador CASE_INSENSITIVE para correspondência sem distinção entre maiúsculas e minúsculas:

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

EDIT: Se s2 contiver caracteres especiais regex (dos quais existem muitos), é importante citá-lo primeiro. Corrigi minha resposta, já que é a primeira que as pessoas verão, mas vote na de Matt Quail desde que ele apontou isso.

Um problema com a resposta de Dave L. é quando s2 contém a marcação regex como \d, etc.

Você deseja chamar Pattern.quote () no s2:

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

Você pode usar

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

A biblioteca Apache Commons é muito útil para esse tipo de coisa. E essa em particular pode ser melhor do que expressões regulares, pois a expressão regular é sempre cara em termos de desempenho.

Uma implementação mais rápida: utilizando String.regionMatches()

O uso do regexp pode ser relativamente lento. (Ser lento) não importa se você deseja apenas verificar em um caso. Mas se você tiver uma matriz ou uma coleção de milhares ou centenas de milhares de strings, as coisas podem ficar bem lentas.

A solução apresentada abaixo não usa expressões regulares nem toLowerCase()(o que também é lento porque cria outras strings e as joga fora após a verificação).

A solução baseia-se no método String.regionMatches () que parece ser desconhecido. Ele verifica se duas Stringregiões correspondem, mas o importante é que ele também tenha uma sobrecarga com um 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álise rápida

Essa análise de velocidade não significa ciência de foguetes, apenas uma imagem aproximada da rapidez com que os diferentes métodos são.

Eu comparo 5 métodos.

1. Nosso método containsIgnoreCase () .
2. Convertendo as duas strings para minúsculas e chamadas String.contains().
3. Convertendo a cadeia de origem em minúscula e chamando String.contains()com a substring pré-armazenada em cache e em minúsculas. Essa solução já não é tão flexível porque testa uma substring de pré-amigo.
4. Usando expressão regular (a resposta aceita Pattern.compile().matcher().find()...)
5. Usando expressão regular, mas com pré-criado e armazenado em cache Pattern. Essa solução já não é tão flexível porque testa uma substring predefinida.

Resultados (chamando o método 10 milhões de vezes):

1. Nosso método: 670 ms
2. 2x paraLowerCase () e contém (): 2829 ms
3. 1x toLowerCase () e contém () com substring em cache: 2446 ms
4. Regexp: 7180 ms
5. Regexp com cache Pattern: 1845 ms

Resultados em uma tabela:

                                            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

Nosso método é 4x mais rápido em comparação com letras minúsculas e usando contains(), 10x mais rápido em comparação com expressões regulares e também 3x mais rápido, mesmo se o Patterncache for pré-armazenado em cache (e perdendo a flexibilidade de verificar se há uma substring arbitrária).

Código do Teste de Análise

Se você estiver interessado em saber como a análise foi realizada, aqui está o aplicativo executável completo:

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

}

Uma maneira mais simples de fazer isso (sem se preocupar com a correspondência de padrões) seria converter os dois Stringem minúsculas:

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

Sim, isso é possível:

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 retornará a String "TRUE!" pois descobriu que seus personagens estavam contidos.

Você pode usar expressões regulares e funciona:

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

Aqui estão alguns compatíveis com Unicode que você pode criar se você usar o ICU4j. Eu acho que "ignorar maiúsculas e minúsculas" é questionável para os nomes dos métodos, porque, embora as comparações de força primária ignorem maiúsculas e minúsculas, elas são descritas como as especificidades dependentes da localidade. Mas espero que seja dependente da localidade da maneira que o usuário esperaria.

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

Fiz um teste para encontrar uma correspondência que não diferencia maiúsculas de minúsculas de uma string. Eu tenho um vetor de 150.000 objetos, todos com uma String como um campo e queria encontrar o subconjunto que correspondesse a uma string. Eu tentei três métodos:

1. Converter tudo em minúsculas

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

2. Use o método String correspondências ()

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

3. Use expressões regulares

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

Os resultados do tempo são:

• Nenhuma tentativa de correspondência: 20 ms

• Para diminuir a correspondência: 182 msegs

• Correspondências de sequência: 278 msegs

• Expressão regular: 65 ms

A expressão regular parece ser a mais rápida para este caso de uso.

Existe uma maneira concisa e simples, usando o sinalizador regex (sem distinção entre maiúsculas e 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)
 * */

Não sei qual é a sua pergunta principal, mas sim, .contains diferencia maiú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;
}

Basicamente, é um método que usa duas strings. Supõe-se que seja uma versão que não diferencia maiúsculas de minúsculas de contains (). Ao usar o método contains, você deseja ver se uma sequência está contida na outra.

Esse método pega a string "sub" e verifica se é igual às substrings da string do contêiner que são iguais em comprimento ao "sub". Se você observar o forloop, verá que ele itera em substrings (que são o comprimento do "sub") sobre a string do contêiner.

Cada iteração verifica se a subcadeia de caracteres da string do contêiner está equalsIgnoreCaseno sub.

Se você precisar pesquisar uma sequência ASCII em outra sequência ASCII, como uma URL , encontrará minha solução melhor. Eu testei o método do icza e o meu pela velocidade e aqui estão os resultados:

• O caso 1 levou 2788 ms - regionMatches
• O caso 2 levou 1520 ms - meu

O 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 com anyMatch e contém 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;
    }

}

ou você pode usar uma abordagem simples e apenas converter o caso da string em caso de substring e, em seguida, use o método contains.

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

Você poderia simplesmente fazer algo assim:

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