Compare one row with multiple values ​​in one expression

Question

I have one String, str variable with possible values, val1 , val2 and val3 .

I want to compare (with an equal case) str with all of these values ​​using an if statement, for example:

 if("val1".equalsIgnoreCase(str)||"val2".equalsIgnoreCase(str)||"val3.equalsIgnoreCase(str)) { //remaining code } 

Is there a way to avoid using multiple OR (||) statements and compare values ​​in a single expression? For example, for example:

  if(("val1" OR "val2" OR "val3").equalsIgnoreCase(str) //this is only an idea. 

Answer 1

I have found a better solution. This can be achieved through RegEx:

 if (str.matches("val1|val2|val3")) { // remaining code } 

For case insensitive matching:

 if (str.matches("(?i)val1|val2|val3")) { // remaining code } 

Answer 2

In Java 8+, you can use Stream<T> and anyMatch(Predicate<? super T>) with something like

 if (Stream.of("val1", "val2", "val3").anyMatch(str::equalsIgnoreCase)) { // ... } 

Answer 3

You can save all the lines you want to compare str with the collection and check if the collection contains str . Save all the strings in the collection as lowercase letters and convert str to lowercase before requesting the collection. For example:

 Set<String> strings = new HashSet<String>(); strings.add("val1"); strings.add("val2"); String str = "Val1"; if (strings.contains(str.toLowerCase())) { } 

Answer 4

ArrayUtils may be helpful.

 ArrayUtils.contains(new String[]{"1", "2"}, "1") 

Answer 5

Low gain to absolutely reliable @hmjd answer : you can use the following syntax:

 class A { final Set<String> strings = new HashSet<>() {{ add("val1"); add("val2"); }}; // ... if (strings.contains(str.toLowerCase())) { } // ... } 

It allows you to initialize you Set in place.

Answer 6

Just use var-args and write your own static method:

 public static boolean compareWithMany(String first, String next, String ... rest) { if(first.equalsIgnoreCase(next)) return true; for(int i = 0; i < rest.length; i++) { if(first.equalsIgnoreCase(rest[i])) return true; } return false; } public static void main(String[] args) { final String str = "val1"; System.out.println(compareWithMany(str, "val1", "val2", "val3")); } 

Answer 7

Another alternative (sort of like qaru.site/questions/124327 / ... above) using StringUtils from the Apache Commons library: https://commons.apache.org/proper/commons-lang/apidocs/org/apach/ General /lang3/StringUtils.html # equalsAnyIgnoreCase-java.lang.CharSequence-java.lang.CharSequence ...-

 if (StringUtils.equalsAnyIgnoreCase(str, "val1", "val2", "val3")) { // remaining code } 

Answer 8

You can achieve this with the Collections structure. Put all your options in a collection, say something like Collection<String> options ;

Then run a loop to compare your string with the list items, and if so, you can return the boolean value true and false otherwise.

Answer 9

Remember that in Java, a String is still a String object. Therefore, you can use the String contains () function to check the range of strings or integers using this method:

 if ("AC Viking GM Ocelot".contains(mAnswer)) {...} 

for numbers it is even more involved, but still works:

 if ("1 4 5 9 10 17 23 96457".contains(String.valueOf(mNumAnswer))) {...} 

Answer 10

Class Apache Commons Collection.

StringUtils.equalsAny (string CharSequence, sequence CharSequence ... searchStrings)

So in your case it would be

StringUtils.equalsAny (str, "val1", "val2", "val3");

Answer 11

Here's a performance test with several alternatives (some are case sensitive and others case insensitive):

 public static void main(String[] args) { // Why 4 * 4: // The test contains 3 values (val1, val2 and val3). Checking 4 combinations will check the match on all values, and the non match; // Try 4 times: lowercase, UPPERCASE, prefix + lowercase, prefix + UPPERCASE; final int NUMBER_OF_TESTS = 4 * 4; final int EXCUTIONS_BY_TEST = 1_000_000; int numberOfMatches; int numberOfExpectedCaseSensitiveMatches; int numberOfExpectedCaseInsensitiveMatches; // Start at -1, because the first execution is always slower, and should be ignored! for (int i = -1; i < NUMBER_OF_TESTS; i++) { int iInsensitive = i % 4; List<String> testType = new ArrayList<>(); List<Long> timeSteps = new ArrayList<>(); String name = (i / 4 > 1 ? "dummyPrefix" : "") + ((i / 4) % 2 == 0 ? "val" : "VAL" )+iInsensitive ; numberOfExpectedCaseSensitiveMatches = 1 <= i && i <= 3 ? EXCUTIONS_BY_TEST : 0; numberOfExpectedCaseInsensitiveMatches = 1 <= iInsensitive && iInsensitive <= 3 && i / 4 <= 1 ? EXCUTIONS_BY_TEST : 0; timeSteps.add(System.currentTimeMillis()); //----------------------------------------- numberOfMatches = 0; testType.add("List (Case sensitive)"); for (int j = 0; j < EXCUTIONS_BY_TEST; j++) { if (Arrays.asList("val1", "val2", "val3").contains(name)) { numberOfMatches++; } } if (numberOfMatches != numberOfExpectedCaseSensitiveMatches) { throw new RuntimeException(); } timeSteps.add(System.currentTimeMillis()); //----------------------------------------- numberOfMatches = 0; testType.add("Set (Case sensitive)"); for (int j = 0; j < EXCUTIONS_BY_TEST; j++) { if (new HashSet<>(Arrays.asList(new String[] {"val1", "val2", "val3"})).contains(name)) { numberOfMatches++; } } if (numberOfMatches != numberOfExpectedCaseSensitiveMatches) { throw new RuntimeException(); } timeSteps.add(System.currentTimeMillis()); //----------------------------------------- numberOfMatches = 0; testType.add("OR (Case sensitive)"); for (int j = 0; j < EXCUTIONS_BY_TEST; j++) { if ("val1".equals(name) || "val2".equals(name) || "val3".equals(name)) { numberOfMatches++; } } if (numberOfMatches != numberOfExpectedCaseSensitiveMatches) { throw new RuntimeException(); } timeSteps.add(System.currentTimeMillis()); //----------------------------------------- numberOfMatches = 0; testType.add("OR (Case insensitive)"); for (int j = 0; j < EXCUTIONS_BY_TEST; j++) { if ("val1".equalsIgnoreCase(name) || "val2".equalsIgnoreCase(name) || "val3".equalsIgnoreCase(name)) { numberOfMatches++; } } if (numberOfMatches != numberOfExpectedCaseInsensitiveMatches) { throw new RuntimeException(); } timeSteps.add(System.currentTimeMillis()); //----------------------------------------- numberOfMatches = 0; testType.add("ArraysBinarySearch(Case sensitive)"); for (int j = 0; j < EXCUTIONS_BY_TEST; j++) { if (Arrays.binarySearch(new String[]{"val1", "val2", "val3"}, name) >= 0) { numberOfMatches++; } } if (numberOfMatches != numberOfExpectedCaseSensitiveMatches) { throw new RuntimeException(); } timeSteps.add(System.currentTimeMillis()); //----------------------------------------- numberOfMatches = 0; testType.add("Java8 Stream (Case sensitive)"); for (int j = 0; j < EXCUTIONS_BY_TEST; j++) { if (Stream.of("val1", "val2", "val3").anyMatch(name::equals)) { numberOfMatches++; } } if (numberOfMatches != numberOfExpectedCaseSensitiveMatches) { throw new RuntimeException(); } timeSteps.add(System.currentTimeMillis()); //----------------------------------------- numberOfMatches = 0; testType.add("Java8 Stream (Case insensitive)"); for (int j = 0; j < EXCUTIONS_BY_TEST; j++) { if (Stream.of("val1", "val2", "val3").anyMatch(name::equalsIgnoreCase)) { numberOfMatches++; } } if (numberOfMatches != numberOfExpectedCaseInsensitiveMatches) { throw new RuntimeException(); } timeSteps.add(System.currentTimeMillis()); //----------------------------------------- numberOfMatches = 0; testType.add("RegEx (Case sensitive)"); // WARNING: if values contains special characters, that should be escaped by Pattern.quote(String) for (int j = 0; j < EXCUTIONS_BY_TEST; j++) { if (name.matches("val1|val2|val3")) { numberOfMatches++; } } if (numberOfMatches != numberOfExpectedCaseSensitiveMatches) { throw new RuntimeException(); } timeSteps.add(System.currentTimeMillis()); //----------------------------------------- numberOfMatches = 0; testType.add("RegEx (Case insensitive)"); // WARNING: if values contains special characters, that should be escaped by Pattern.quote(String) for (int j = 0; j < EXCUTIONS_BY_TEST; j++) { if (name.matches("(?i)val1|val2|val3")) { numberOfMatches++; } } if (numberOfMatches != numberOfExpectedCaseInsensitiveMatches) { throw new RuntimeException(); } timeSteps.add(System.currentTimeMillis()); //----------------------------------------- numberOfMatches = 0; testType.add("StringIndexOf (Case sensitive)"); // WARNING: the string to be matched should not contains the SEPARATOR! final String SEPARATOR = ","; for (int j = 0; j < EXCUTIONS_BY_TEST; j++) { // Don't forget the SEPARATOR at the begin and at the end! if ((SEPARATOR+"val1"+SEPARATOR+"val2"+SEPARATOR+"val3"+SEPARATOR).indexOf(SEPARATOR + name + SEPARATOR)>=0) { numberOfMatches++; } } if (numberOfMatches != numberOfExpectedCaseSensitiveMatches) { throw new RuntimeException(); } timeSteps.add(System.currentTimeMillis()); //----------------------------------------- StringBuffer sb = new StringBuffer("Test ").append(i) .append("{ name : ").append(name) .append(", numberOfExpectedCaseSensitiveMatches : ").append(numberOfExpectedCaseSensitiveMatches) .append(", numberOfExpectedCaseInsensitiveMatches : ").append(numberOfExpectedCaseInsensitiveMatches) .append(" }:\n"); for (int j = 0; j < testType.size(); j++) { sb.append(String.format(" %4d ms with %s\n", timeSteps.get(j + 1)-timeSteps.get(j), testType.get(j))); } System.out.println(sb.toString()); } } 

Conclusion (only in the worst case, when you need to check all the elements without matching with any):

 Test 4{ name : VAL0, numberOfExpectedCaseSensitiveMatches : 0, numberOfExpectedCaseInsensitiveMatches : 0 }: 43 ms with List (Case sensitive) 378 ms with Set (Case sensitive) 22 ms with OR (Case sensitive) 254 ms with OR (Case insensitive) 35 ms with ArraysBinarySearch(Case sensitive) 266 ms with Java8 Stream (Case sensitive) 531 ms with Java8 Stream (Case insensitive) 1009 ms with RegEx (Case sensitive) 1201 ms with RegEx (Case insensitive) 107 ms with StringIndexOf (Case sensitive) 

Answer 12

No, there is no such possibility. In any case, one could imagine:

 public static boolean contains(String s, Collection<String>c) { for (String ss : c) { if (s.equalsIgnoreCase(ss)) return true; } return false; } 

Answer 13

 !string.matches("a|b|c|d") 

works great for me.