Compare one String with multiple values in one expression

Question

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

I want to compare (with equal case) str to 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 (||) operators and compare values in one expression? For example, like this:

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

possible duplicate of [A Cleaner IF Statement](http://stackoverflow.com/questions/20952325/a-cleaner-if-statement) — WoodenKitty, Jan 17 '15 at 03:07

kundan bora · Accepted Answer · 2018-08-03T07:07:50.433

127

I found the 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
}

edited Aug 03 '18 at 07:07

answered Apr 18 '12 at 15:59

kundan bora

3,821
2
20
29

2

The `matches` function does not work well for all cases. The answer of @hmjd did it for my case. See [Regex doesn't work in String.matches()](http://stackoverflow.com/questions/8923398/regex-doesnt-work-in-string-matches) for more info. – Primoz990 May 11 '17 at 10:20
3

Be aware this is the least performant solution according to Manuel Romeiro but I think it's one of the more readable solutions. – David Bradley Jun 05 '20 at 13:03
using regex is not performant in long running cases kindly refer to my detailed reason, https://stackoverflow.com/a/62447007/2083529 – user2083529 Jun 18 '20 at 09:42

score 83 · Answer 2 · edited Dec 06 '17 at 17:17

83

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

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

edited Dec 06 '17 at 17:17

ZhekaKozlov

36,558
20
126
155

answered Dec 03 '16 at 21:08

Elliott Frisch

198,278
20
158
249

score 18 · Answer 3 · answered Apr 18 '12 at 08:16

18

You could store all the strings that you want to compare str with into a collection and check if the collection contains str. Store all strings in the collection as lowercase and convert str to lowercase before querying the collection. For example:

Set<String> strings = new HashSet<String>();
strings.add("val1");
strings.add("val2");

String str = "Val1";

if (strings.contains(str.toLowerCase()))
{
}

answered Apr 18 '12 at 08:16

hmjd

120,187
20
207
252

You can populate the collection with whatever values you require. In case if `str` was `"val"` then in the code in my answer `strings.contains()` would return `false`. – hmjd Apr 18 '12 at 08:25
No no i am saying that if someone pass str value as "Val" which is not as equal as "Val1","Val2,"Val3". That mean passing str value as "Val" must be failed.. but in your case this will be pass.Not satisfy my condition. – kundan bora Apr 18 '12 at 08:28
From the question case is irrelevant due to presence of `equalsIgnoreCase()`. If `"Val"` is passed and `strings` contains `"val1"`, `"val2"`, and `"val3"` then `contains()` will return `false`. See http://ideone.com/LiYKP . – hmjd Apr 18 '12 at 08:35
Oh you used HashSet to store Strings . OK I got this. – kundan bora Apr 18 '12 at 09:24
or `new TreeSet<>(String.CASE_INSENSITIVE_ORDER)`. `if (strings.contains(str)) { ... }`. No need to call `String.toLowerCase()` – Venkata Raju Dec 26 '18 at 19:01
@Venkata, the argument of TreeSet constructor it's only for sort porpoises, not for convert "contains" method into case insensitive – Manuel Romeiro Sep 07 '21 at 16:13

score 12 · Answer 4 · answered Nov 19 '18 at 23:06

Yet another alternative (kinda similar to https://stackoverflow.com/a/32241628/6095216 above) using StringUtils from the apache commons library: https://commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/StringUtils.html#equalsAnyIgnoreCase-java.lang.CharSequence-java.lang.CharSequence...-

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

Manuel Romeiro · Answer 5 · 2021-08-11T18:29:24.533

Here a performance test with multiples 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());
    }
}

Output (only the worse case, that is when have to check all elements without match none):

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)

Output provided by Warpspeed SCP, changing the test to fill the collections outside of the loops, simulationg the code when the list of values to test never change (and the collections can be cached).

(don't compare the time of this test with the previous test, since it was executed on different environment, but compare only the time of different strategies for the same test):

Test 4{ name : VAL0, numberOfExpectedCaseSensitiveMatches : 0, numberOfExpectedCaseInsensitiveMatches : 0 }:
    26 ms with List (Case sensitive)
    6 ms with Set (Case sensitive)
    12 ms with OR (Case sensitive)
    371 ms with OR (Case insensitive)
    14 ms with ArraysBinarySearch(Case sensitive)
    100 ms with Java8 Stream (Case sensitive)
    214 ms with Java8 Stream (Case insensitive)
    773 ms with RegEx (Case sensitive)
    946 ms with RegEx (Case insensitive)
    37 ms with StringIndexOf (Case sensitive)

Here's a benchmark with collection declarations extracted out: [pastebin](https://hatebin.com/qzpiqybmsv) — Warpspeed SCP, Aug 10 '21 at 06:26
Note how the times for some of these operations keep shrinking as the benchmark progresses. — Warpspeed SCP, Aug 10 '21 at 06:34
Thanks for that new benchmark, that can be used on normal code when the list of values to test never change (and the collections can be cached) — Manuel Romeiro, Aug 11 '21 at 18:15

score 6 · Answer 6 · answered Aug 27 '15 at 05:53

6

ArrayUtils may be helpful.

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

answered Aug 27 '15 at 05:53

Jeffrey4l

123
3
6

score 4 · Answer 7 · answered Mar 19 '20 at 01:16

4

Starting from Java 9, you can use either of following

List.of("val1", "val2", "val3").contains(str.toLowerCase())

Set.of("val1", "val2", "val3").contains(str.toLowerCase());

answered Mar 19 '20 at 01:16

Ankush

675
2
13
29

score 3 · Answer 8 · edited May 23 '17 at 12:10

3

Small enhancement to perfectly valid @hmjd's answer: you can use 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.

edited May 23 '17 at 12:10

Community

1
1

answered Sep 14 '15 at 10:51

Andrey Starodubtsev

5,139
3
32
46

score 3 · Answer 9 · answered Jul 31 '20 at 11:45

3

For those who came here for exact equality checks (not ignoring case), I find that

if (Arrays.asList(str1, str2, str3).contains(strToCheck)) {
    ...
}

is one of, if the most concise solution, and is available on Java 7.

answered Jul 31 '20 at 11:45

Drackmord

71
1
7

It looks like a part of this answer https://stackoverflow.com/a/60036035/3166697 – Dima Kozhevin Jul 31 '20 at 12:23

score 2 · Answer 10 · answered Apr 18 '12 at 08:19

2

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

answered Apr 18 '12 at 08:19

Neet

3,937
15
18

I like this one! I'm probably overlooking something, but why do you include `next` as a parameter? That can just as well be part of the var-args `rest`, right? – Martijn May 10 '15 at 09:44
By having 'next' I enforce passing at least _one_ parameter. So you can not do `compareWithMany("foo")`. It's a compile-time sanity check, instead of having to deal with an empty set to compare against during runtime. – Neet May 11 '15 at 18:00

score 2 · Answer 11 · answered Dec 26 '18 at 18:40

2

Apache Commons Collection class.

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

So in your case, it would be

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

answered Dec 26 '18 at 18:40

Vivek Dixit

31
2

score 2 · Answer 12 · answered Jun 18 '20 at 09:40

The are many solutions suggested and most are working solutions. However i must add here that people suggesting using regex i.e str.matches("val1|val2|val3") is okay however

it's not performant if the method/code is called many times
it's not null safe

I would suggest to use apache commons lang3 stringUtils StringUtils.equalsAny(str, "val1", "val2", "val3") instead

Test:

public static void main(String[] args) {
        String var = "val1";
        long t, t1 = 0, t2 = 0;

        for (int i = 0; i < 1000; i++) {
            t = System.currentTimeMillis();
            var.matches("val1|val2|val3");
            t1 += System.currentTimeMillis() - t;

            t = System.currentTimeMillis();
            StringUtils.equalsAny(var, "val1", "val2", "val3");
            t2 += System.currentTimeMillis() - t;
        }
        System.out.println("Matches took + " + t1 + " ms\nStringUtils took " + t2 + " ms");
    }

Results after 1000 iteration:

Matches took + 18 ms
StringUtils took 7 ms

FYI `StringUtils.equalsAny` is just a for of the strings and a `string.equals(var)` just in case you don't want to import the hole StringUtils just for this. — PhoneixS, Mar 10 '21 at 08:58

score 1 · Answer 13 · answered Dec 05 '22 at 16:56

1

Kotlin is good enough to make it without regex:

setOf("say", "no", "war").contains(your_string)

answered Dec 05 '22 at 16:56

Konstantin Konopko

5,229
4
36
62

score 0 · Answer 14 · answered Apr 18 '12 at 08:21

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

Then loop throgh this to compare your string with the list elements and if it is you can return a boolean value true and otherwise false.

Stuart Walsh · Answer 15 · 2017-01-19T08:52:47.067

0

Remember in Java a quoted String is still a String object. Therefore you can use the String function contains() to test for a range of Strings or integers using this method:

if ("A C Viking G M Ocelot".contains(mAnswer)) {...}

for numbers it's a tad more involved but still works:

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

edited Jan 19 '17 at 08:52

answered Jan 19 '17 at 08:46

Stuart Walsh

31
1
3

This solution returns false positives! For example for mAnswer= "king", will return true, but should be false. Don't forget to prefix and suffix the mAnswer with the separator (and also the string with all possibilities to match) , and then use the "contains" method – Manuel Romeiro Sep 07 '21 at 16:05

Marco Carlo Moriggi · Answer 16 · 2021-09-10T15:54:05.023

0

Sorry for reponening this old question, for Java 8+ I think the best solution is the one provided by Elliott Frisch (Stream.of("str1", "str2", "str3").anyMatches(str::equalsIgnoreCase)) but it seems like it's missing one of the simplest solution for eldest version of Java:

if(Arrays.asList("val1", "val2", "val3", ..., "val_n").contains(str.toLowerCase())){
//...
}

You could apply some error prevenction by checking the non-nullity of variable str, and by caching the list once created.

// List of lower-case possibilities
final List<String> list = Arrays.asList("val1", "val2", "val3", ..., "val_n");
for(String str : somethingYouCouldTheReadStringFrom()){
  if(str != null && list.contains(str.toLowerCase())){
    //...
  }
}

edited Sep 10 '21 at 15:54

answered Feb 03 '20 at 09:08

Marco Carlo Moriggi

324
4
11

1

How do you speed up creating a new object (ArrayList)? Are you telling that ArrayList is more performant than the List returned by Arrays.asList? – Manuel Romeiro Sep 07 '21 at 15:54
You're rigth, no performance gain wrapping with an ArrayList: in both cases the `contains()` method traverses the whole list linearly. I made a wrong supposition with ArrayList: I supposed that internally uses a hash-index, but looking at the source code both kind of arrays simply look through all the elements of the internal array, sorry. I'll edit my previous answer, thanks for the correction – Marco Carlo Moriggi Sep 10 '21 at 15:48

score 0 · Answer 17 · answered Feb 03 '20 at 09:18

Since this question has been reopened anyway, I might just as well propose an enum solution.

enum ValidValues {
   VAL1, VAL2, VAL3;

   public static boolean isValid(String input) {
       return Stream.of(ValidValues.values())
                    .map(ValidValues::name)
                    .anyMatch(s -> s.equalsIgnoreCase(input));
   }
}

Or you can just use the stream statement with

Stream.of("val1", "val2", "val3")
      .anyMatch(s -> s.equalsIgnoreCase(str))

if you only use it in one place.

score 0 · Answer 18 · answered Jan 04 '23 at 10:13

0

boolean contains = "string2".matches(TextUtils.join("|", new String[]{"string1", "string2"}));

answered Jan 04 '23 at 10:13

Homayoon Ahmadi

1,181
1
12
24

Bru · Answer 19 · 2016-11-14T10:50:04.090

-2

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

works fine for me.

edited Nov 14 '16 at 10:50

answered Nov 10 '16 at 10:09

Bru

11
1

6

Please give explanation / reason for better answer, It is too short – sangram parmar Nov 10 '16 at 10:14

score -3 · Answer 20 · answered Apr 18 '12 at 08:17

-3

No, there is no such possibility. Allthough, one could imagine:

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

answered Apr 18 '12 at 08:17

slipset

2,960
2
21
17

For the collections worth to consider, like HashSet, contains() has much more efficient implementation. – Alexei Kaigorodov Apr 18 '12 at 08:24
True, but (which may be a moot point), equals and equalsIgnoreCase do not yield the same result. This could of course be overcome by storing the strings as lower case and lowercasing the key you're looking for, but, YMMV – slipset Apr 18 '12 at 08:27

Compare one String with multiple values in one expression

20 Answers20

Linked

Related