Wie kann ich überprüfen, ob ein String in Java einen anderen String enthält, ohne die Groß- und Kleinschreibung zu beachten?

Angenommen, ich habe zwei Saiten,

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

Ich möchte eine Überprüfung durchführen, die die s2darin enthaltene Rückgabe zurückgibt s1. Ich kann das machen mit:

return s1.contains(s2);

Ich bin mir ziemlich sicher, dass zwischen contains()Groß- und Kleinschreibung unterschieden wird, aber ich kann dies nicht sicher anhand der Dokumentation feststellen. Wenn ja, dann wäre meine beste Methode wahrscheinlich so etwas wie:

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

Abgesehen davon gibt es einen anderen (möglicherweise besseren) Weg, dies zu erreichen, ohne sich um die Groß- und Kleinschreibung zu kümmern?

Ja, enthält Groß- und Kleinschreibung. Sie können java.util.regex.Pattern mit dem Flag CASE_INSENSITIVE verwenden, um die Groß- und Kleinschreibung nicht zu berücksichtigen:

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

BEARBEITEN: Wenn s2 Regex-Sonderzeichen enthält (von denen es viele gibt), ist es wichtig, diese zuerst zu zitieren. Ich habe meine Antwort korrigiert, da es die erste ist, die die Leute sehen werden, aber stimmen Sie die von Matt Quail ab, seit er darauf hingewiesen hat.

Ein Problem mit der Antwort von Dave L. ist, wenn s2 Regex-Markups wie \dusw. enthält.

Sie möchten Pattern.quote () auf s2 aufrufen:

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

Sie können verwenden

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

Die Apache Commons- Bibliothek ist für solche Dinge sehr nützlich. Und dieser spezielle Ausdruck ist möglicherweise besser als reguläre Ausdrücke, da Regex in Bezug auf die Leistung immer teuer ist.

Eine schnellere Implementierung: Nutzen String.regionMatches()

Die Verwendung von Regexp kann relativ langsam sein. Es ist (langsam) egal, ob Sie nur in einem Fall überprüfen möchten. Aber wenn Sie ein Array oder eine Sammlung von Tausenden oder Hunderttausenden von Zeichenfolgen haben, kann es ziemlich langsam werden.

Die unten dargestellte Lösung verwendet weder reguläre Ausdrücke noch toLowerCase()(was auch langsam ist, weil es andere Zeichenfolgen erstellt und diese nach der Prüfung einfach wegwirft).

Die Lösung baut auf der String.regionMatches () -Methode auf, die unbekannt zu sein scheint. Es wird geprüft, ob zwei StringRegionen übereinstimmen. Wichtig ist jedoch, dass es auch eine Überlastung mit einem praktischen ignoreCaseParameter gibt.

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

Geschwindigkeitsanalyse

Diese Geschwindigkeitsanalyse bedeutet nicht, Raketenwissenschaft zu sein, sondern nur ein grobes Bild davon, wie schnell die verschiedenen Methoden sind.

Ich vergleiche 5 Methoden.

1. Unsere Methode includesIgnoreCase () .
2. Durch Konvertieren beider Zeichenfolgen in Kleinbuchstaben und Aufrufen String.contains().
3. Durch Konvertieren der Quellzeichenfolge in Kleinbuchstaben und Aufrufen String.contains()mit der vorab zwischengespeicherten Teilzeichenfolge in Kleinbuchstaben. Diese Lösung ist bereits nicht so flexibel, da sie einen vordefinierten Teilstring testet.
4. Mit regulären Ausdrücken (die akzeptierte Antwort Pattern.compile().matcher().find()...)
5. Mit regulären Ausdrücken, aber mit vorgefertigten und zwischengespeicherten Pattern. Diese Lösung ist bereits nicht so flexibel, da sie einen vordefinierten Teilstring testet.

Ergebnisse (durch 10 Millionen Aufruf der Methode):

1. Unsere Methode: 670 ms
2. 2x toLowerCase () und enthält (): 2829 ms
3. 1x toLowerCase () und enthält () mit zwischengespeicherter Teilzeichenfolge: 2446 ms
4. Regexp: 7180 ms
5. Regexp mit zwischengespeichertem Pattern: 1845 ms

Ergebnisse in einer Tabelle:

                                            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

Unsere Methode ist 4x schneller als die Verwendung von Kleinbuchstaben und die Verwendung contains(), 10x schneller als die Verwendung regulärer Ausdrücke und 3x schneller, selbst wenn die Patternvorab zwischengespeichert ist (und die Flexibilität bei der Suche nach einem beliebigen Teilstring verliert).

Analyse-Testcode

Wenn Sie interessiert sind, wie die Analyse durchgeführt wurde, finden Sie hier die vollständige ausführbare Anwendung:

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

}

Eine einfachere Möglichkeit, dies zu tun (ohne sich um den Mustervergleich zu kümmern), besteht darin, beide Strings in Kleinbuchstaben umzuwandeln :

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

Ja, das ist erreichbar:

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;

Dieser Code gibt den String "TRUE!" Zurück. als sich herausstellte, dass Ihre Charaktere enthalten waren.

Sie können reguläre Ausdrücke verwenden und es funktioniert:

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

Hier sind einige Unicode-freundliche, die Sie erstellen können, wenn Sie ICU4j verwenden. Ich denke, "Groß- / Kleinschreibung ignorieren" ist für die Methodennamen fraglich, da Primärstärkevergleiche Groß- und Kleinschreibung zwar ignorieren, sie jedoch als länderabhängig beschrieben werden. Aber es ist hoffentlich in einer Weise vom Gebietsschema abhängig, die der Benutzer erwarten würde.

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

Ich habe einen Test durchgeführt, bei dem eine Übereinstimmung einer Zeichenfolge ohne Berücksichtigung der Groß- und Kleinschreibung festgestellt wurde. Ich habe einen Vektor von 150.000 Objekten, alle mit einer Zeichenfolge als einem Feld, und wollte die Teilmenge finden, die einer Zeichenfolge entspricht. Ich habe drei Methoden ausprobiert:

1. Konvertieren Sie alles in Kleinbuchstaben

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

2. Verwenden Sie die Methode String match ()

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

3. Verwenden Sie reguläre Ausdrücke

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

Timing-Ergebnisse sind:

• Keine versuchte Übereinstimmung: 20 ms

• Zum Verringern der Übereinstimmung: 182 ms

• String-Übereinstimmungen: 278 ms

• Regulärer Ausdruck: 65 ms

Der reguläre Ausdruck scheint für diesen Anwendungsfall der schnellste zu sein.

Es gibt eine einfache, übersichtliche Möglichkeit, das Regex-Flag zu verwenden (Groß- und Kleinschreibung wird nicht berücksichtigt {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)
 * */

Ich bin nicht sicher, was Ihre Hauptfrage hier ist, aber ja, .contains unterscheidet zwischen Groß- und Kleinschreibung.

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

Grundsätzlich ist es eine Methode, die zwei Zeichenfolgen benötigt. Es soll sich um eine Version handeln, bei der die Groß- und Kleinschreibung nicht berücksichtigt wird. Wenn Sie die Methode includes verwenden, möchten Sie sehen, ob eine Zeichenfolge in der anderen enthalten ist.

Diese Methode verwendet die Zeichenfolge "sub" und prüft, ob sie den Teilzeichenfolgen der Containerzeichenfolge entspricht, deren Länge der von "sub" entspricht. Wenn Sie sich die forSchleife ansehen, werden Sie feststellen, dass sie in Teilzeichenfolgen (dh der Länge des "Sub") über die Containerzeichenfolge iteriert.

Bei jeder Iteration wird überprüft, ob sich die Teilzeichenfolge der Containerzeichenfolge equalsIgnoreCaseim Sub befindet.

Wenn Sie eine ASCII-Zeichenfolge in einer anderen ASCII-Zeichenfolge wie einer URL suchen müssen, ist meine Lösung besser. Ich habe die Methode von icza und meine auf Geschwindigkeit getestet und hier sind die Ergebnisse:

• Fall 1 dauerte 2788 ms - regionMatches
• Fall 2 dauerte 1520 ms - meine

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

Wir können Stream mit anyMatch verwenden und enthält 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;
    }

}

Oder Sie können einen einfachen Ansatz verwenden und einfach die Groß- / Kleinschreibung der Zeichenfolge in die Groß- / Kleinschreibung der Teilzeichenfolge konvertieren und dann die Methode includes verwenden.

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

Sie könnten einfach so etwas tun:

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