Ich habe zwei String
s, str1
und str2
. Wie überprüfe ich, ob str2
in str1
enthalten ist, wobei die Groß-/Kleinschreibung ignoriert wird?
str1.toLowerCase().contains(str2.toLowerCase())
Wie wäre es mit matches()
?
String string = "Madam, I am Adam";
// Starts with
boolean b = string.startsWith("Mad"); // true
// Ends with
b = string.endsWith("dam"); // true
// Anywhere
b = string.indexOf("I am") >= 0; // true
// To ignore case, regular expressions must be used
// Starts with
b = string.matches("(?i)mad.*");
// Ends with
b = string.matches("(?i).*adam");
// Anywhere
b = string.matches("(?i).*i am.*");
Wenn Sie org.Apache.commons.lang.StringUtils verwenden können, empfehle ich Folgendes:
String container = "aBcDeFg";
String content = "dE";
boolean containerContainsContent = StringUtils.containsIgnoreCase(container, content);
Sie können die Methode toLowerCase()
verwenden:
public boolean contains( String haystack, String needle ) {
haystack = haystack == null ? "" : haystack;
needle = needle == null ? "" : needle;
// Works, but is not the best.
//return haystack.toLowerCase().indexOf( needle.toLowerCase() ) > -1
return haystack.toLowerCase().contains( needle.toLowerCase() )
}
Rufen Sie es dann auf mit:
if( contains( str1, str2 ) ) {
System.out.println( "Found " + str2 + " within " + str1 + "." );
}
Beachten Sie, dass Sie Ihre eigene Methode wieder verwenden können, indem Sie sie erstellen. Wenn dann jemand darauf hinweist, dass Sie contains
anstelle von indexOf
verwenden sollten, müssen Sie nur eine einzige Codezeile ändern.
Ich bevorzuge auch die RegEx-Lösung. Der Code wird viel sauberer sein. Ich würde zögern, toLowerCase () in Situationen zu verwenden, in denen ich wusste, dass die Zeichenfolgen groß sein würden, da Zeichenfolgen unveränderlich sind und kopiert werden müssten. Außerdem ist die Lösung von matches () möglicherweise verwirrend, da ein regulärer Ausdruck als Argument verwendet wird (die Suche nach "Need $ le" ist problematisch).
Aufbauend auf einigen der obigen Beispiele:
public boolean containsIgnoreCase( String haystack, String needle ) {
if(needle.equals(""))
return true;
if(haystack == null || needle == null || haystack .equals(""))
return false;
Pattern p = Pattern.compile(needle,Pattern.CASE_INSENSITIVE+Pattern.LITERAL);
Matcher m = p.matcher(haystack);
return m.find();
}
example call:
String needle = "Need$le";
String haystack = "This is a haystack that might have a need$le in it.";
if( containsIgnoreCase( haystack, needle) ) {
System.out.println( "Found " + needle + " within " + haystack + "." );
}
(Hinweis: Möglicherweise möchten Sie NULL und leere Zeichenfolgen je nach Ihren Anforderungen unterschiedlich behandeln. Ich denke, dass sie meiner Meinung nach näher an der Java -Spezifikation für Zeichenfolgen liegen.)
Geschwindigkeitskritische Lösungen könnten das Durchlaufen des Heuhaufens durch Zeichen umfassen, die nach dem ersten Zeichen der Nadel suchen. Wenn das erste Zeichen übereinstimmt (Groß- und Kleinschreibung wird nicht beachtet), durchlaufen Sie die Nadel zeichenweise, suchen Sie das entsprechende Zeichen im Heuhaufen und geben Sie "true" zurück, wenn alle Zeichen übereinstimmen. Wenn ein nicht übereinstimmendes Zeichen gefunden wird, setzen Sie die Iteration durch den Heuhaufen beim nächsten Zeichen fort und geben "false" zurück, wenn eine Position> haystack.length () - needle.length () erreicht ist.
Ich würde eine Kombination aus der Methode contain und der Methode toUpper
verwenden, die Teil der Klasse String sind. Ein Beispiel ist unten:
String string1 = "AAABBBCCC";
String string2 = "DDDEEEFFF";
String searchForThis = "AABB";
System.out.println("Search1="+string1.toUpperCase().contains(searchForThis.toUpperCase()));
System.out.println("Search2="+string2.toUpperCase().contains(searchForThis.toUpperCase()));
Dies wird zurückkehren:
Search1 = true
Search2 = false