In Java, come posso controllare se una stringa contiene una sottostringa (ignorando il caso)?

Question

Ho due String s, str1 e str2. Come posso verificare se str2 è contenuto all'interno di str1, ignorando la custodia?

Answer 1

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

Answer 2

È possibile utilizzare il metodo 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()) 
} 

quindi chiamare utilizzando:

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

Si noti che con la creazione di un proprio metodo, è possibile riutilizzarlo. Quindi, quando qualcuno sottolinea che è necessario utilizzare contains anziché indexOf, è necessario modificare solo una singola riga di codice.

Answer 3

Vorrei usare una combinazione del metodo contiene e del metodo toUpper che fanno parte della classe String. Un esempio è qui sotto:

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

Ciò restituirà:

SEARCH1 = true
Search2 = false

Answer 4

Come su 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

Se siete in grado di utilizzare org.apache.commons.lang.StringUtils, io suggerisco di usare il seguente:

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

Answer 6

Ho anche favorire la soluzione RegEx. Il codice sarà molto più pulito. Avrei esitato a usare aLowerCase() in situazioni in cui sapevo che le stringhe sarebbero state grandi, poiché le stringhe sono immutabili e dovrebbero essere copiate. Inoltre, la soluzione matches() potrebbe essere confusa perché richiede un'espressione regolare come argomento (la ricerca di "Need $ le" potrebbe essere problematica).

costruzione su alcuni degli esempi di cui sopra:

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

(Nota:. Si potrebbe desiderare di gestire le stringhe NULL e vuoti in modo diverso a seconda delle esigenze penso che modo mi hanno è più vicino alle specifiche Java per le stringhe.)

Le soluzioni critiche della velocità potrebbero includere l'iterazione del carattere di pagliaio di carattere alla ricerca del primo carattere dell'ago. Quando il primo carattere è abbinato (caso in modo insensibile), inizia a scorrere l'ago carattere per carattere, cercando il carattere corrispondente nel pagliaio e restituendo "true" se tutti i caratteri vengono abbinati. Se si incontra un personaggio non abbinato, riprendi l'iterazione attraverso il pagliaio al carattere successivo, restituendo "falso" se viene raggiunta una posizione> haystack.length() - needle.length().