Teste si une chaîne contient l'une des chaînes d'un tableau

Comment tester une chaîne pour voir si elle contient l'une des chaînes d'un tableau?

À la place d'utiliser

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

EDIT: Voici une mise à jour utilisant l'API Java 8 Streaming. Tellement plus propre. Peut également être combiné avec des expressions régulières.

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

De plus, si nous changeons le type d'entrée en List au lieu d'un tableau, nous pouvons utiliser items.parallelStream().anyMatch(inputStr::contains).

Vous pouvez également utiliser .filter(inputStr::contains).findAny()si vous souhaitez renvoyer la chaîne correspondante.

Réponse originale légèrement datée:

Voici une méthode statique (TRÈS BASIQUE). Notez qu'il est sensible à la casse sur les chaînes de comparaison. Une façon primitive de le rendre insensible à la casse serait d'appeler toLowerCase()ou toUpperCase()à la fois sur les chaînes d'entrée et de test.

Si vous avez besoin de faire quelque chose de plus compliqué que cela, je vous recommande de regarder les classes Pattern et Matcher et d'apprendre à faire des expressions régulières. Une fois que vous les avez compris, vous pouvez utiliser ces classes ou la String.matches()méthode d'assistance.

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;

Utils de chaîne

Utilisation:

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

Il renverra l'index de la chaîne trouvée ou -1 si aucun n'est trouvé.

Vous pouvez utiliser la méthode String # matches comme ceci:

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

Le moyen le plus simple serait probablement de convertir le tableau en java.util.ArrayList. Une fois qu'il est dans une arraylist, vous pouvez facilement utiliser la méthode contains.

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

Si vous utilisez Java 8 ou supérieur, vous pouvez compter sur l' API Stream pour faire une telle chose:

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

En supposant que vous ayez un grand tableau de big Stringà tester, vous pouvez également lancer la recherche en parallèle en appelant parallel(), le code serait alors:

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

Voici une solution:

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;
}

Depuis la version 3.4 Apache Common Lang 3 implémente la méthode containsAny .

Une approche plus groovyesque serait d'utiliser inject en combinaison avec métaclasse :

J'adorerais dire:

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

Et la méthode serait:

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

Si vous avez besoin que containsAny soit présent pour toute future variable String, ajoutez la méthode à la classe au lieu de l'objet:

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

Essaye ça:

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

Et si vous recherchez une correspondance insensible à la casse, utilisez le modèle

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

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

}

Si vous seraching pour entiers mots que vous pouvez faire ce qui fonctionne le cas insensible .

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;
}

On peut aussi faire comme ça:

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

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

Ce qui suit devrait fonctionner pour vous en supposant que Strings est le tableau dans lequel vous recherchez:

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

où mykeytosearch est la chaîne dont vous souhaitez tester l'existence dans le tableau. mysearchComparator - est un comparateur qui serait utilisé pour comparer des chaînes.

Reportez-vous à Arrays.binarySearch pour plus d'informations.

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