W języku Java Jak sprawdzić, czy łańcuch znaków zawiera podłańcuch (ignorując wielkość liter)? [duplikat]

A może 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.*");

Jeśli jesteś w stanie użyć org.Apacz.commons.lang.StringUtils , proponuję użyć następującego:

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

Możesz użyć metody toLowerCase():

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

Następnie wywołaj go używając:

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

Zauważ, że tworząc własną metodę, możesz ją ponownie użyć. Następnie, gdy ktoś wskazuje, że powinieneś użyć contains zamiast indexOf, Masz tylko jedną linię kodu do zmiany.

Popieram również rozwiązanie RegEx. Kod będzie dużo czystszy. Wahałbym się użyć metody toLowerCase () w sytuacjach, w których wiedziałem, że ciągi będą duże, ponieważ ciągi są niezmienne i muszą zostać skopiowane. Ponadto, rozwiązanie matches () może być mylące, ponieważ przyjmuje jako argument Wyrażenie regularne (szukanie "need$le" jest problematyczne).

Bazując na niektórych z powyższych przykładów:

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

(Uwaga: możesz chcieć obsłużyć NULL i empty struny inaczej w zależności od potrzeb. Myślę, że sposób, w jaki mam to jest bliżej specyfikacji Java dla ciągów.)

Rozwiązania o znaczeniu krytycznym dla szybkości mogą obejmować iterację przez stóg siana znak po znaku, szukając pierwszego znaku igły. Gdy pierwszy znak zostanie dopasowany (bez rozróżniania wielkości liter), rozpocznij iterację przez znak igły po znaku, szukając odpowiadającego znaku w stogu siana i zwracając "true", jeśli wszystkie znaki zostaną dopasowane. Jeśli a napotkany jest niezatwierdzony znak, Wznów iterację przez stóg siana przy następnym znaku, zwracając "false", jeśli pozycja > stóg siana.długość () - igła.długość() została osiągnięta.

Użyłbym kombinacji metody contains i metody toUpper, które są częścią klasy String. Przykład znajduje się poniżej:

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

To zwróci:

Search1 = true
Search2 = false