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
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));
}
Since version 3.4 Apache Common Lang 3 implement the containsAny method.
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()) {
...
}
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);
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;
}
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.
if (Arrays.asList(array).contains(string))
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.
Try this:
if (Arrays.asList(item1, item2, item3).stream().anyMatch(string::contains))
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.
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;
}
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)})
}
You can use String#matches method like this:
System.out.printf("Matches - [%s]%n", string.matches("^.*?(item1|item2|item3).*$"));
Source: Stackoverflow.com