Testen Sie, ob eine Zeichenfolge eine der Zeichenfolgen aus einem Array enthält

Wie teste ich eine Zeichenfolge, um festzustellen, ob sie Zeichenfolgen aus einem Array enthält?

Anstatt zu verwenden

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

BEARBEITEN: Hier ist ein Update mit der Java 8 Streaming API. So viel sauberer. Kann auch noch mit regulären Ausdrücken kombiniert werden.

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

Wenn wir den Eingabetyp in eine Liste anstelle eines Arrays ändern, können wir ihn auch verwenden items.parallelStream().anyMatch(inputStr::contains) .

Sie können auch verwenden, .filter(inputStr::contains).findAny()wenn Sie die übereinstimmende Zeichenfolge zurückgeben möchten.

Ursprüngliche leicht veraltete Antwort:

Hier ist eine (SEHR GRUNDLEGENDE) statische Methode. Beachten Sie, dass bei den Vergleichszeichenfolgen zwischen Groß- und Kleinschreibung unterschieden wird. Eine primitive Möglichkeit, die Groß- und Kleinschreibung nicht zu berücksichtigen, besteht darin, die Eingabe- und die Testzeichenfolge aufzurufen toLowerCase()oder toUpperCase()zu aktivieren.

Wenn Sie etwas komplizierteres tun müssen, würde ich empfehlen, sich das Muster anzusehen und Matcher Klassen und lernen , wie man einige reguläre Ausdrücke zu tun. Sobald Sie diese verstanden haben, können Sie diese Klassen oder die String.matches()Hilfsmethode verwenden.

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

Verwenden:

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

Es wird der Index der gefundenen Zeichenfolge oder -1 zurückgegeben, wenn keine gefunden wird.

Sie können die String # match- Methode wie folgt verwenden:

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

Der einfachste Weg wäre wahrscheinlich, das Array in eine java.util.ArrayList zu konvertieren. Sobald es sich in einer Arrayliste befindet, können Sie die Contains-Methode problemlos nutzen.

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

Wenn Sie Java 8 oder höher verwenden, können Sie sich auf die Stream-API verlassen , um Folgendes zu tun:

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

Angenommen, Sie haben eine große Auswahl an Big- StringTests, können Sie die Suche auch parallel durch Aufrufen starten. parallel()Der Code lautet dann:

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

Hier ist eine Lösung:

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

Seit der Version 3.4 Apache Commons Lang 3 , um die Umsetzung containsAny Methode.

Ein groovyesque Ansatz wäre die Verwendung inject in Kombination mit Metaklasse :

Ich würde gerne sagen:

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

Und die Methode wäre:

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

Wenn Sie containsAny anwesend zu sein für jedes zukünftige String - Variable dann das Verfahren auf die anstelle der Objektklasse hinzu:

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

Versuche dies:

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

Wenn Sie nach einer Übereinstimmung suchen, bei der die Groß- und Kleinschreibung nicht berücksichtigt wird, verwenden Sie das Muster

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

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

}

Wenn Sie nach ganzen Wörtern suchen , können Sie dies tun, ohne die Groß- und Kleinschreibung zu beachten .

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

Das können wir auch so machen:

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

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

Das Folgende sollte für Sie funktionieren, vorausgesetzt, Strings ist das Array, in dem Sie suchen:

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

Dabei ist mykeytosearch die Zeichenfolge, die Sie auf Existenz innerhalb des Arrays testen möchten. mysearchComparator - ist ein Komparator, der zum Vergleichen von Zeichenfolgen verwendet wird.

Weitere Informationen finden Sie unter Arrays.binarySearch .

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