Teste se uma string contém alguma das strings de uma matriz

Como testar uma string para ver se ela contém alguma das strings de uma matriz?

Ao invés de usar

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

EDIT: Aqui está uma atualização usando o Java 8 Streaming API. Muito mais limpo. Ainda pode ser combinado com expressões regulares também.

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

Além disso, se alterarmos o tipo de entrada para uma lista em vez de uma matriz, podemos usar items.parallelStream().anyMatch(inputStr::contains).

Você também pode usar .filter(inputStr::contains).findAny()se desejar retornar a sequência correspondente.

Resposta original ligeiramente datada:

Aqui está um método estático (MUITO BÁSICO). Observe que diferencia maiúsculas de minúsculas nas seqüências de comparação. Uma maneira primitiva de diferenciar maiúsculas de minúsculas seria chamar toLowerCase()ou toUpperCase()nas cadeias de entrada e de teste.

Se você precisar fazer algo mais complicado do que isso, recomendo examinar as classes Pattern e Matcher e aprender a fazer algumas expressões regulares. Depois de entender essas, você pode usar essas classes ou o 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;

Utilitários de String

Usar:

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

Ele retornará o índice da sequência encontrada ou -1 se nenhuma for encontrada.

Você pode usar o método String # corresponde assim:

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

A maneira mais fácil provavelmente seria converter a matriz em um java.util.ArrayList. Uma vez em uma lista de matrizes, você pode facilmente aproveitar o método contains.

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

Se você usa o Java 8 ou superior, pode confiar na API Stream para fazer isso:

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

Supondo que você tenha uma grande variedade de coisas grandes Stringpara testar, você também pode iniciar a pesquisa em paralelo chamando parallel(), o código seria:

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

Aqui está uma solução:

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 a versão 3.4, o Apache Common Lang 3 implementa o método containsAny .

Uma abordagem mais groovyesque seria usar injetar em combinação com metaClass :

Eu adoraria dizer:

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

E o método seria:

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

Se você precisar que o containsAny esteja presente para qualquer variável String futura, adicione o método à classe em vez do objeto:

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

Tente o seguinte:

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

E se você estiver procurando por correspondência sem distinção entre maiúsculas e minúsculas, use o padrão

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

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

}

Se você busca palavras inteiras, pode fazer isso que não diferencia maiúsculas de 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;
}

Também podemos fazer assim:

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

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

O abaixo deve funcionar para você, assumindo que Strings é a matriz em que você está pesquisando:

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

onde mykeytosearch é a sequência que você deseja testar quanto à existência na matriz. mysearchComparator - é um comparador que seria usado para comparar strings.

Consulte Arrays.binarySearch para obter mais informações.

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