W języku Java, w jaki sposób sprawdzić, czy ciąg zawiera podłańcuch (ignorowanie przypadku)?

Question

Mam dwa String s, str1 i str2. Jak sprawdzić, czy str2 jest zawarty w , ignorując przypadek?

Answer 1

str1.toLowerCase().contains(str2.toLowerCase()) 

Answer 2

Można 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 połączyć go za pomocą:

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

Zauważ, że tworząc swoją własną metodę, można je ponownie wykorzystać. Następnie, gdy ktoś zauważy, że powinieneś użyć contains zamiast indexOf, musisz zmienić tylko jeden wiersz kodu.

Answer 3

Chciałbym użyć kombinacji metody contains i metody toUpper, które są częścią klasy String. Przykładem jest 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())); 

ten powróci:

search1 = true
Search2 = false

Answer 4

Jak o 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 5

Jeśli jesteś w stanie wykorzystać org.apache.commons.lang.StringUtils, proponuję przy użyciu następujących:

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

Answer 6

I sprzyjać również rozwiązanie regex. Kod będzie znacznie czystszy. Wahałbym się użyć do LowerCase() w sytuacjach, w których wiedziałem, że struny będą duże, ponieważ ciągi są niezmienne i musiałyby być skopiowane. Również rozwiązanie matches() może być mylące, ponieważ jako argument przyjmuje wyrażenie regularne (szukanie "Need $ le" jest problematyczne).

Opierając się 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że chcesz obsługiwać NULL i pustych ciągów różnie w zależności od potrzeb Myślę, że sposób mam to bliżej specyfikacji Java w przypadku ciągów znaków.)

Rozwiązania o ograniczonej szybkości mogą obejmować iterację poprzez znak stogu siana przez postać szukającą pierwszego znaku igły. Kiedy pierwszy znak zostanie dopasowany (przypadek nieistniejący), zacznij powtarzać igłę po znaku, szukając odpowiedniego znaku w stogu siana i zwracając "true", jeśli wszystkie postacie zostaną dopasowane. Jeśli napotkany zostanie nie dopasowany znak, wznów iterację za pośrednictwem stogu siana na następnym znaku, zwracając "false", jeśli osiągnięta zostanie pozycja> haystack.length() - needle.length().