How do I test a string to see if it contains any of the strings from an array?
Instead of using
if (string.contains(item1) || string.contains(item2) || string.contains(item3))
This question is related to
java
string
if-statement
You can use String#matches method like this:
System.out.printf("Matches - [%s]%n", string.matches("^.*?(item1|item2|item3).*$"));
The below should work for you assuming Strings is the array that you are searching within:
Arrays.binarySearch(Strings,"mykeytosearch",mysearchComparator);
where mykeytosearch is the string that you want to test for existence within the array. mysearchComparator - is a comparator that would be used to compare strings.
Refer to Arrays.binarySearch for more information.
We can also do like this:
if (string.matches("^.*?((?i)item1|item2|item3).*$"))
(?i): used for case insensitive
.*? & .*$: used for checking whether it is present anywhere in between the string.
Try this:
if (Arrays.asList(item1, item2, item3).stream().anyMatch(string::contains))
If you use Java 8 or above, you can rely on the Stream API to do such thing:
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);
}
Assuming that you have a big array of big String
to test you could also launch the search in parallel by calling parallel()
, the code would then be:
return Arrays.stream(items).parallel().anyMatch(inputString::contains);
And if you are looking for case insensitive match, use pattern
Pattern pattern = Pattern.compile("\\bitem1 |item2\\b",java.util.regex.Pattern.CASE_INSENSITIVE);
Matcher matcher = pattern.matcher(input);
if (matcher.find()) {
...
}
The easiest way would probably be to convert the array into a java.util.ArrayList. Once it is in an arraylist, you can easily leverage the contains method.
public static boolean bagOfWords(String str)
{
String[] words = {"word1", "word2", "word3", "word4", "word5"};
return (Arrays.asList(words).contains(str));
}
if (Arrays.asList(array).contains(string))
Since version 3.4 Apache Common Lang 3 implement the containsAny method.
Here is one solution :
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;
}
If you are seraching for whole words you can do this that works case insensitive.
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;
}
import org.apache.commons.lang.StringUtils;
Use:
StringUtils.indexOfAny(inputString, new String[]{item1, item2, item3})
It will return the index of the string found or -1 if none is found.
A more groovyesque approach would be to use inject in combination with metaClass:
I would to love to say:
String myInput="This string is FORBIDDEN"
myInput.containsAny(["FORBIDDEN","NOT_ALLOWED"]) //=>true
And the method would be:
myInput.metaClass.containsAny={List<String> notAllowedTerms->
notAllowedTerms?.inject(false,{found,term->found || delegate.contains(term)})
}
If you need containsAny to be present for any future String variable then add the method to the class instead of the object:
String.metaClass.containsAny={notAllowedTerms->
notAllowedTerms?.inject(false,{found,term->found || delegate.contains(term)})
}
Source: Stackoverflow.com