web-dev-qa-db-fra.com

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

Comment puis-je 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))
javastringcoding-styleif-statement
113
user1060828

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

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

De plus, si nous modifions le type d'entrée en une liste 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. Un moyen de rendre primitive insensible à la casse consiste à appeler toLowerCase() ou toUpperCase() à la fois dans 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 méthode d'assistance String.matches().

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;
}
135
gnomed
import org.Apache.commons.lang.StringUtils;

String Utils

Utilisation: 

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

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

48
renanleandrof

Vous pouvez utiliser String # correspond à méthode comme ceci:

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

Le moyen le plus simple serait probablement de convertir le tableau en un fichier Java.util.ArrayList. Une fois inscrit dans une liste, vous pouvez facilement utiliser la méthode contient.

public static boolean bagOfWords(String str)
{
    String[] words = {"Word1", "Word2", "Word3", "Word4", "Word5"};  
    return (Arrays.asList(words).contains(str));
}
19
Roy Kachouh

Si vous utilisez Java 8 ou une version ultérieure, vous pouvez vous fier à l’API Stream pour ce faire:

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 une grande gamme de variables 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);
13
Nicolas Filotto

Essaye ça:

if (Arrays.asList(item1, item2, item3).contains(string))
6
Óscar López

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

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

1
Arthur Vaïsse

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

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

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

}
0
vsingh

Une approche plus groovyesque serait d’utiliser inject en combinaison avec metaClass :

Je voudrais aimer 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 de containsAny pour être présent pour toute variable de chaîne future, ajoutez la méthode à la classe plutôt que l'objet:

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