Comment vérifier si une chaîne contient une autre chaîne de manière insensible à la casse en Java?

Dis que j'ai deux cordes,

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

Je veux effectuer un retour de vérification qui s2est contenu dans s1. Je peux le faire avec:

return s1.contains(s2);

Je suis à peu près sûr que cela contains()respecte la casse, mais je ne peux pas le déterminer avec certitude en lisant la documentation. Si c'est le cas, je suppose que ma meilleure méthode serait quelque chose comme:

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

Tout cela mis à part, existe-t-il une autre façon (peut-être meilleure) d'accomplir cela sans se soucier de la sensibilité à la casse?

Oui, contient est sensible à la casse. Vous pouvez utiliser java.util.regex.Pattern avec l'indicateur CASE_INSENSITIVE pour la correspondance insensible à la casse:

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

EDIT: Si s2 contient des caractères spéciaux regex (dont il y en a beaucoup), il est important de le citer d'abord. J'ai corrigé ma réponse car c'est la première que les gens verront, mais votez pour Matt Quail depuis qu'il l'a souligné.

Un problème avec la réponse de Dave L. est lorsque s2 contient un balisage d'expression régulière tel que \d, etc.

Vous voulez appeler Pattern.quote () sur s2:

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

Vous pouvez utiliser

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

La bibliothèque Apache Commons est très utile pour ce genre de chose. Et celle-ci peut être meilleure que les expressions régulières car l'expression régulière est toujours coûteuse en termes de performances.

Une mise en œuvre plus rapide: utilisation String.regionMatches()

L'utilisation d'expressions régulières peut être relativement lente. Cela (être lent) n'a pas d'importance si vous voulez simplement vérifier dans un cas. Mais si vous avez un tableau ou une collection de milliers ou de centaines de milliers de chaînes, les choses peuvent devenir assez lentes.

La solution présentée ci-dessous n'utilise pas d'expressions régulières ni toLowerCase()(ce qui est également lent car il crée une autre chaîne et la jette juste après la vérification).

La solution s'appuie sur la méthode String.regionMatches () qui semble inconnue. Il vérifie si 2 Stringrégions correspondent, mais ce qui est important, c'est qu'il a également une surcharge avec un ignoreCaseparamètre pratique .

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

Analyse de vitesse

Cette analyse de la vitesse ne signifie pas être une science de fusée, juste une image approximative de la rapidité des différentes méthodes.

Je compare 5 méthodes.

1. Notre méthode containsIgnoreCase () .
2. En convertissant les deux chaînes en minuscules et en appelant String.contains().
3. En convertissant la chaîne source en minuscules et appelez String.contains()avec la sous-chaîne pré-mise en cache et en minuscules. Cette solution n'est déjà pas aussi flexible car elle teste une sous-chaîne prédéfinie.
4. Utiliser l'expression régulière (la réponse acceptée Pattern.compile().matcher().find()...)
5. Utilisation d'expressions régulières mais avec pré-création et mise en cache Pattern. Cette solution n'est déjà pas aussi flexible car elle teste une sous-chaîne prédéfinie.

Résultats (en appelant la méthode 10 millions de fois):

1. Notre méthode: 670 ms
2. 2x toLowerCase () et contient (): 2829 ms
3. 1x toLowerCase () et contient () avec sous-chaîne en cache: 2446 ms
4. Expression rationnelle: 7180 ms
5. Expression régulière avec mise en cache Pattern: 1845 ms

Résultats dans un tableau:

                                            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

Notre méthode est 4 fois plus rapide par rapport à l'utilisation de minuscules et à l'utilisation contains(), 10 fois plus rapide que l' utilisation d'expressions régulières et également 3 fois plus rapide même si le Patternest pré-mis en cache (et perd la flexibilité de vérifier une sous-chaîne arbitraire).

Code de test d'analyse

Si vous êtes intéressé par la façon dont l'analyse a été effectuée, voici l'application exécutable complète:

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

}

Une façon plus simple de le faire (sans se soucier de la correspondance des modèles) serait de convertir les deux Strings en minuscules:

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

Oui, c'est réalisable:

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;

Ce code renverra la chaîne "TRUE!" car il a constaté que vos personnages étaient contenus.

Vous pouvez utiliser des expressions régulières , et cela fonctionne:

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

Voici quelques-uns compatibles avec Unicode que vous pouvez créer si vous utilisez ICU4j. Je suppose que "ignorer la casse" est discutable pour les noms de méthode, car bien que les comparaisons de force principales ignorent la casse, elles sont décrites comme étant spécifiques aux paramètres régionaux. Mais il est à espérer que cela dépend des paramètres régionaux d'une manière attendue par l'utilisateur.

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

J'ai fait un test pour trouver une correspondance insensible à la casse d'une chaîne. J'ai un vecteur de 150 000 objets tous avec une chaîne comme un champ et je voulais trouver le sous-ensemble qui correspondait à une chaîne. J'ai essayé trois méthodes:

1. Convertir tout en minuscules

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

2. Utilisez la méthode String matches ()

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

3. Utilisez des expressions régulières

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

Les résultats de chronométrage sont:

• Aucune tentative de correspondance: 20 ms

• Pour réduire la correspondance: 182 ms

• Correspondances de chaînes: 278 ms

• Expression régulière: 65 ms

L'expression régulière semble être la plus rapide pour ce cas d'utilisation.

Il existe un moyen simple et concis, en utilisant le drapeau regex (insensible à la casse {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)
 * */

Je ne sais pas quelle est votre question principale ici, mais oui, .contains est sensible à la casse.

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

Fondamentalement, c'est une méthode qui prend deux chaînes. Il est censé être une version non sensible à la casse de contains (). Lorsque vous utilisez la méthode contains, vous voulez voir si une chaîne est contenue dans l'autre.

Cette méthode prend la chaîne qui est «sous» et vérifie si elle est égale aux sous-chaînes de la chaîne de conteneur qui sont égales en longueur au «sous». Si vous regardez la forboucle, vous verrez qu'elle itère dans des sous-chaînes (qui sont la longueur du "sous") sur la chaîne de conteneur.

Chaque itération vérifie si la sous-chaîne de la chaîne de conteneur correspond equalsIgnoreCaseau sous.

Si vous devez rechercher une chaîne ASCII dans une autre chaîne ASCII, telle qu'une URL , vous trouverez ma solution meilleure. J'ai testé la méthode et la mienne d'icza pour la vitesse et voici les résultats:

• Le cas 1 a pris 2788 ms - regionMatches
• Le cas 2 a pris 1520 ms - mon

Le code:

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

Nous pouvons utiliser stream avec anyMatch et contient de 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 vous pouvez utiliser une approche simple et convertir simplement le cas de la chaîne en cas de sous-chaîne, puis utiliser la méthode contient.

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

Vous pouvez simplement faire quelque chose comme ceci:

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