Prueba si una cadena contiene alguna de las cadenas de una matriz

¿Cómo pruebo una cadena para ver si contiene alguna de las cadenas de una matriz?

En lugar de usar

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

EDITAR: Aquí hay una actualización que usa la API Java 8 Streaming. Mucho más limpio. Todavía se puede combinar con expresiones regulares también.

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

Además, si cambiamos el tipo de entrada a una Lista en lugar de una matriz que podemos usar items.parallelStream().anyMatch(inputStr::contains).

También puede usar .filter(inputStr::contains).findAny()si desea devolver la cadena coincidente.

Respuesta original ligeramente anticuada:

Aquí hay un método estático (MUY BÁSICO). Tenga en cuenta que distingue entre mayúsculas y minúsculas en las cadenas de comparación. Una forma primitiva de hacer que no distinga entre mayúsculas y minúsculas sería llamar toLowerCase()o toUpperCase()en las cadenas de entrada y prueba.

Si necesita hacer algo más complicado que esto, le recomendaría que mire las clases de Patrón y Matcher y aprenda a hacer algunas expresiones regulares. Una vez que los comprenda, puede usar esas clases o el String.matches()método auxiliar.

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;

Utilidades de cadena

Utilizar:

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

Devolverá el índice de la cadena encontrada o -1 si no se encuentra ninguno.

Puede usar el método String # coincide de esta manera:

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

La forma más fácil probablemente sería convertir la matriz en java.util.ArrayList. Una vez que se encuentra en una lista de arrays, puede aprovechar fácilmente el método contiene.

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

Si usa Java 8 o superior, puede confiar en Stream API para hacer lo siguiente:

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

Suponiendo que tiene una gran variedad de grandes Stringpara probar, también podría iniciar la búsqueda en paralelo llamando parallel(), el código sería:

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

Aquí hay una solución:

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

Desde la versión 3.4, Apache Common Lang 3 implementa el método contiene cualquier .

Un enfoque más groovyesco sería usar inyectar en combinación con metaClass :

Me encantaría decir:

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

Y el método sería:

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

Si necesita contieneAny para estar presente en cualquier variable de cadena futura, agregue el método a la clase en lugar del objeto:

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

Prueba esto:

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

Y si está buscando una coincidencia entre mayúsculas y minúsculas, use el patrón

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

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

}

Si está buscando palabras completas , puede hacer esto que no distingue entre mayúsculas y minúsculas .

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

También podemos hacer así:

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

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

Lo siguiente debería funcionar para usted suponiendo que Strings es la matriz en la que está buscando:

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

donde mykeytosearch es la cadena que desea probar para la existencia dentro de la matriz. mysearchComparator: es un comparador que se usaría para comparar cadenas.

Consulte Arrays.binarySearch para obtener más información.

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