Sprawdź, czy łańcuch zawiera którykolwiek z łańcuchów z tablicy

Question

Jak przetestować ciąg znaków, aby sprawdzić, czy zawiera on ciągi z tablicy?

Zamiast

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

Answer 1

EDYCJA: Tutaj jest aktualizacja przy użyciu API Java 8 Streaming. O wiele czystszy. Można nadal łączyć z wyrażeniami regularnymi.

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

Ponadto, jeśli zamiast tego zmienić typ wejścia do listy tablicy możemy użyć items.parallelStream().anyMatch(inputStr::contains).

Możesz również użyć .filter(inputStr::contains).findAny(), jeśli chcesz zwrócić pasujący ciąg.

---

Original nieco przestarzały odpowiedź:

Oto (bardzo podstawowy) metoda statyczna. Zwróć uwagę, że w łańcuchach porównania rozróżniana jest wielkość liter. Aby uczynić go niewrażliwym na wielkość liter, należy wywołać toLowerCase() lub toUpperCase() zarówno na łańcuchach wejściowych, jak i testowych.

Jeśli chcesz zrobić coś bardziej skomplikowanego, polecam przejrzeć klasy Pattern i Matcher i nauczyć się wykonywać niektóre wyrażenia regularne. Po ich zrozumieniu można użyć tych klas lub metody pomocniczej 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; 
} 

Answer 2

Najprostszym sposobem byłoby prawdopodobnie przekształcić tablicę do java.util.ArrayList. Gdy znajduje się na liście tablic, możesz łatwo wykorzystać metodę zawiera.

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

Answer 3

Spróbuj tego:

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

Answer 4

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

Answer 5

Można użyć String#matches metody takie jak to:

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

Answer 6

Poniższa powinny pracować dla Ciebie zakładając Strings jest tablica, że przeszukują w:

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

gdzie mykeytosearch jest ciągiem, który chcesz przetestować pod kątem istnienia w tablicy. mysearchComparator - to komparator, który byłby używany do porównywania ciągów.

Aby uzyskać więcej informacji, patrz Arrays.binarySearch.

Answer 7

Bardziej groovyesque podejście byłoby użyć wstrzyknąć w połączeniu z metaklasa:

Chciałbym kochać powiedzieć:

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

A metoda będzie:

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

Jeśli potrzebujesz containsAny być obecny na każdej przyszłej zmienna String następnie dodać metodę do klasy zamiast obiektu:

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

Answer 8

import org.apache.commons.lang.StringUtils; 

String Utils

Zastosowanie:

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

Zwróci indeks znalezionego ciągu lub -1, jeśli nie zostanie znaleziony.

Answer 9

Oto jedno rozwiązanie:

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

Answer 10

String.prototype.matchWithTokens = function(tokensArray){ 
    for(i=0; i< tokensArray.length; i++) { 
    if(this.indexOf(tokensArray[i]) != -1) { 
     return true; 
    } 
    } 
    return false; 
}; 

Answer 11

Jeśli używasz Java 8 lub powyżej, można polegać na Stream API zrobić coś takiego:

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

Zakładając, że masz duży zestaw String do przetestowania, możesz również zrównoleglić wyszukiwanie przez wywołanie parallel(), kod będzie wtedy:

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

Answer 12

A jeśli szukasz przypadku meczu niewrażliwego, wykorzystanie wzorca

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

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

}