Bir dizenin bir dizideki dizelerden herhangi birini içerip içermediğini test edin

Bir dizeden dizeden herhangi birini içerip içermediğini görmek için bir dizeyi nasıl test edebilirim?

Kullanmak yerine

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

EDIT: İşte Java 8 Streaming API kullanarak bir güncelleme. Çok daha temiz. Yine de düzenli ifadelerle birleştirilebilir.

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

Ayrıca, girdi türünü bir dizi yerine bir Liste olarak değiştirirsek, items.parallelStream().anyMatch(inputStr::contains) .

.filter(inputStr::contains).findAny()Eşleşen dizeyi döndürmek istiyorsanız da kullanabilirsiniz .

Orijinal biraz tarihli cevap:

İşte bir (ÇOK TEMEL) statik yöntem. Karşılaştırma dizelerinde büyük / küçük harfe duyarlı olduğunu unutmayın. Büyük / küçük harfe duyarsız hale getirmenin ilkel bir yolu , hem giriş hem de test dizelerini çağırmak toLowerCase()ya da çağırmak olacaktır toUpperCase().

Bundan daha karmaşık bir şey yapmanız gerekiyorsa, Pattern ve Matcher sınıflarına bakmanızı ve bazı düzenli ifadelerin nasıl yapılacağını öğrenmenizi öneririm . Bunları anladıktan sonra, bu sınıfları veya String.matches()yardımcı yöntemi kullanabilirsiniz.

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;

String Utils

kullanın:

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

Bulunan dizenin dizinini veya hiçbiri bulunmazsa -1 değerini döndürür.

String # match yöntemini şu şekilde kullanabilirsiniz :

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

En kolay yol muhtemelen diziyi bir java.util.ArrayList'e dönüştürmektir. Bir arrayliste girdikten sonra, içerme yöntemini kolayca kullanabilirsiniz.

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

Eğer kullanırsanız Java 8 veya üstünde, güvenebileceğiniz Akış API böyle bir şey yapmak için:

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

StringTest etmek için büyük bir dizi diziniz olduğu varsayılarak aramayı paralel olarak başlatabileceğinizi varsayarsak parallel(), kod şöyle olur:

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

İşte bir çözüm:

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

3.4 sürümünden beri Apache Common Lang 3 includeAny yöntemini uygular .

Daha mükemmel bir yaklaşım, enjeksiyonu metaClass ile birlikte kullanmak olacaktır :

Söylemek isterim:

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

Ve yöntem şöyle olurdu:

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

Eğer gerekiyorsa containsAny ileride dize değişkeni sonra yerine nesnenin sınıfına yöntemi ekleyin hazır bulunmak için:

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

Bunu dene:

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

Ve büyük / küçük harfe duyarlı olmayan eşleşme arıyorsanız, desen kullanın

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

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

}

Tam kelimeler için seraching ediyorsanız, bunu büyük / küçük harfe duyarsız çalıştırabilirsiniz .

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

Bunu da yapabiliriz:

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

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

Aşağıda, Dizelerin içinde aradığınız dizi olduğunu varsayarak çalışmanız gerekir :

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

burada mykeytosearch, dizideki varlığını test etmek istediğiniz dizedir. mysearchComparator - dizeleri karşılaştırmak için kullanılacak bir karşılaştırıcıdır.

Arrays.binarySearch sayfasına bakın fazla bilgi .

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