Wie prüfe ich in Java, ob eine Zeichenkette eine Teilzeichenkette enthält (ohne Berücksichtigung der Groß-/Kleinschreibung)?

Question

Ich habe zwei String s, str1 y str2 . Wie kann ich prüfen, ob str2 ist enthalten in str1 Fall ignorieren?

Answer 1

str1.toUpperCase().contains(str2.toUpperCase())

UPD:

Die ursprüngliche Antwort lautete toLowerCase() Methode. Aber wie einige Leute richtig bemerkt haben, gibt es einige Ausnahmen in Unicode und es ist besser, die Methode toUpperCase() . Weil:

Es gibt Sprachen, die mehr als eine Variante der Kleinschreibung für eine Variante der Großschreibung kennen.

Answer 2

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.*");

Answer 3

Wenn Sie in der Lage sind, die org.apache.commons.lang.StringUtils schlage ich vor, Folgendes zu verwenden:

String container = "aBcDeFg";
String content = "dE";
boolean containerContainsContent = StringUtils.containsIgnoreCase(container, content);

Answer 4

Sie können die toLowerCase() Methode:

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

Dann rufen Sie es mit auf:

if( contains( str1, str2 ) ) {
  System.out.println( "Found " + str2 + " within " + str1 + "." );
}

Beachten Sie, dass Sie Ihre eigene Methode erstellen und wiederverwenden können. Wenn Sie dann jemand darauf hinweist, dass Sie die Methode contains anstelle von indexOf müssen Sie nur eine einzige Zeile des Codes ändern.

Answer 5

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 weiß, dass die Zeichenfolgen groß sein werden, da Zeichenfolgen unveränderlich sind und kopiert werden müssten. Außerdem könnte die matches()-Lösung verwirrend sein, da sie einen regulären Ausdruck als Argument benötigt (die Suche nach "Need$le" könnte problematisch sein).

Aufbauend auf einigen der oben genannten 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: NULL und leere Zeichenketten können je nach Bedarf unterschiedlich behandelt werden. Ich denke, die Art, wie ich es habe, ist näher an der Java-Spezifikation für Strings).

Zu den geschwindigkeitskritischen Lösungen könnte gehören, dass der Heuhaufen Zeichen für Zeichen durchlaufen wird, um das erste Zeichen der Nadel zu finden. Wenn das erste Zeichen übereinstimmt (unabhängig von der Groß-/Kleinschreibung), wird die Nadel zeichenweise durchlaufen, um das entsprechende Zeichen im Heuhaufen zu finden, und "true" zurückgegeben, wenn alle Zeichen übereinstimmen. Wird ein nicht übereinstimmendes Zeichen gefunden, wird die Iteration durch den Heuhaufen beim nächsten Zeichen fortgesetzt und "false" zurückgegeben, wenn eine Position > haystack.length() - needle.length() erreicht wird.