web-dev-qa-db-de.com

Wie überprüfe ich in Java, ob eine Zeichenfolge eine Teilzeichenfolge enthält (Groß- / Kleinschreibung wird ignoriert)?

Ich habe zwei Strings, str1 und str2. Wie überprüfe ich, ob str2 in str1 enthalten ist, wobei die Groß-/Kleinschreibung ignoriert wird?

507
trinity
str1.toLowerCase().contains(str2.toLowerCase())
1008
Igor Artamonov

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

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);
31
Mojo

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.

21

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.

10
Michael Cooper

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

7
SOA Nerd