Verifica se una stringa contiene una qualsiasi delle stringhe di un array

Come testare una stringa per vedere se contiene una delle stringhe di un array?

Invece di usare

if (string.contains(item1) || string.contains(item2) || string.contains(item3))

EDIT: ecco un aggiornamento usando l'API Streaming Java 8. Molto più pulito. Può ancora essere combinato anche con espressioni regolari.

public static boolean stringContainsItemFromList(String inputStr, String[] items) {
    return Arrays.stream(items).parallel().anyMatch(inputStr::contains);
}

Inoltre, se cambiamo il tipo di input in un Elenco anziché in un array, possiamo usarlo items.parallelStream().anyMatch(inputStr::contains).

È inoltre possibile utilizzare .filter(inputStr::contains).findAny()se si desidera restituire la stringa corrispondente.

Risposta originale leggermente datata:

Ecco un metodo statico (MOLTO BASE). Si noti che è sensibile al maiuscolo / minuscolo sulle stringhe di confronto. Un modo primitivo per rendere maiuscole e minuscole sarebbe quello di chiamare toLowerCase()o toUpperCase()su entrambe le stringhe di input e test.

Se hai bisogno di fare qualcosa di più complicato di questo, consiglierei di guardare le classi Pattern e Matcher e imparare come fare alcune espressioni regolari. Una volta che li capisci, puoi usare quelle classi o il String.matches()metodo helper.

public static boolean stringContainsItemFromList(String inputStr, String[] items)
{
    for(int i =0; i < items.length; i++)
    {
        if(inputStr.contains(items[i]))
        {
            return true;
        }
    }
    return false;
}

import org.apache.commons.lang.StringUtils;

Utensili a corda

Uso:

StringUtils.indexOfAny(inputString, new String[]{item1, item2, item3})

Restituirà l'indice della stringa trovata o -1 se non viene trovata alcuna.

È possibile utilizzare il metodo Match # string in questo modo:

System.out.printf("Matches - [%s]%n", string.matches("^.*?(item1|item2|item3).*$"));

Il modo più semplice sarebbe probabilmente convertire l'array in un file java.util.ArrayList. Una volta che è in un arraylist, puoi facilmente sfruttare il metodo contenute.

public static boolean bagOfWords(String str)
{
    String[] words = {"word1", "word2", "word3", "word4", "word5"};  
    return (Arrays.asList(words).contains(str));
}

Se usi Java 8 o versioni successive, puoi fare affidamento sull'API Stream per fare ciò:

public static boolean containsItemFromArray(String inputString, String[] items) {
    // Convert the array of String items as a Stream
    // For each element of the Stream call inputString.contains(element)
    // If you have any match returns true, false otherwise
    return Arrays.stream(items).anyMatch(inputString::contains);
}

Supponendo che tu abbia una vasta gamma di grandi Stringda testare, potresti anche avviare la ricerca in parallelo chiamando parallel(), il codice sarebbe quindi:

return Arrays.stream(items).parallel().anyMatch(inputString::contains); 

Ecco una soluzione:

public static boolean containsAny(String str, String[] words)
{
   boolean bResult=false; // will be set, if any of the words are found
   //String[] words = {"word1", "word2", "word3", "word4", "word5"};

   List<String> list = Arrays.asList(words);
   for (String word: list ) {
       boolean bFound = str.contains(word);
       if (bFound) {bResult=bFound; break;}
   }
   return bResult;
}

Dalla versione 3.4 di Apache comune Lang 3 implementare il containsAny metodo.

Un approccio più groovyesque sarebbe usare iniettare in combinazione con metaClass :

Mi piacerebbe dire:

String myInput="This string is FORBIDDEN"
myInput.containsAny(["FORBIDDEN","NOT_ALLOWED"]) //=>true

E il metodo sarebbe:

myInput.metaClass.containsAny={List<String> notAllowedTerms->
   notAllowedTerms?.inject(false,{found,term->found || delegate.contains(term)})
}

Se hai bisogno di contieneAny per essere presente per qualsiasi futura variabile String, aggiungi il metodo alla classe anziché all'oggetto:

String.metaClass.containsAny={notAllowedTerms->
   notAllowedTerms?.inject(false,{found,term->found || delegate.contains(term)})
}

Prova questo:

if (Arrays.asList(item1, item2, item3).stream().anyMatch(string::contains))

E se stai cercando una corrispondenza senza distinzione tra maiuscole e minuscole, usa il modello

Pattern pattern = Pattern.compile("\\bitem1 |item2\\b",java.util.regex.Pattern.CASE_INSENSITIVE);

    Matcher matcher = pattern.matcher(input);
    if(matcher.find() ){ 

}

Se stai cercando parole intere , puoi farlo senza distinzione tra maiuscole e minuscole .

private boolean containsKeyword(String line, String[] keywords)
{
    String[] inputWords = line.split(" ");

    for (String inputWord : inputWords)
    {
        for (String keyword : keywords)
        {
            if (inputWord.equalsIgnoreCase(keyword))
            {
                return true;
            }
        }
    }

    return false;
}

Possiamo anche fare così:

if (string.matches("^.*?((?i)item1|item2|item3).*$"))

(?i): used for case insensitive
.*? & .*$: used for checking whether it is present anywhere in between the string.

Di seguito dovrebbe funzionare per te supponendo che Strings sia l'array in cui stai cercando:

Arrays.binarySearch(Strings,"mykeytosearch",mysearchComparator);

dove mykeytosearch è la stringa che si desidera verificare l'esistenza all'interno dell'array. mysearchComparator - è un comparatore che verrebbe utilizzato per confrontare le stringhe.

Fare riferimento a Arrays.binarySearch per ulteriori informazioni.

if (Arrays.asList(array).contains(string))