Format Multiple ‘or’ Conditions in an If Statement in Java

1. Overview

While using an if statement, we might need multiple conditions in it with logical operators such as AND or OR. This may not be a clean design and affects the code’s readability and cognitive complexity.

In this tutorial, we’ll see the alternatives to format multiple value conditions in an if statement.

2. Can We Avoid If Statements?

Suppose we have an e-commerce platform and set up a discount for people born in specific months. Let’s have a look at a code snippet:

if (month == 10 || month == 11) {
    // doSomething()
} else if(month == 4 || month == 5) {
    // doSomething2()
} else {
    // doSomething3()
}

This might lead to some code that is difficult to read. Also, even if we have good test coverage, the code may be hard to maintain as it forces us, for example, to put together what different conditions are to execute a specific action.

2.1. Use Clean Code

We can apply patterns to replace many if statements. For example, we can move the logic of an if’s multiple conditions into a class or an Enum. At runtime, we’ll switch between interfaces based on the client input. Similarly, we can have a look at the Strategy pattern.

This does not strictly relate to formatting and usually leads to rethinking the logic. Nonetheless, it is something we can consider to improve our design.

2.2. Improve Methods Syntax

However, there is nothing wrong with using the if / else logic as long as the code is readable and easy to maintain. For example, let’s consider this code snippet:

if (month == 8 || month == 9) {
    return doSomething();
} else {
    return doSomethingElse();
}

As a first step, we can avoid using the else part:

if (month == 8 || month == 9) {
    return doSomething();
}

return doSomethingElse();

Also, some other code can be improved, for example, by replacing month numbers with Enum of java.time package:

if (month == OCTOBER || month == NOVEMBER || month == DECEMBER) {
    return doSomething();
}
// ...

These are simple yet effective code improvements. So, before applying complex patterns, we first should see if we can ease the code readability.

We’ll also see how to use functional programming. In Java, this applies from version 8 with the lambda expression syntax.

3. Tests Legend

Following the e-commerce discount example, we’ll create tests and check values in the discount months. For instance, from October to December. We’ll assert false otherwise. We’ll set random months that are either in or out of the ones allowed:

Month monthIn() {
    return Month.of(rand.ints(10, 13)
      .findFirst()
      .orElse(10));
}

Month monthNotIn() {
    return Month.of(rand.ints(1, 10)
      .findFirst()
      .orElse(1));
}

There could be multiple if conditions, although, for simplicity, we’ll assume just one if / else statement.

4. Use Switch

An alternative to using an if logic is the switch command. Let’s see how we can use it in our example:

boolean switchMonth(Month month) {
    switch (month) {
        case OCTOBER:
        case NOVEMBER:
        case DECEMBER:
            return true;
        default:
            return false;
    }
}

Notice it will be moving down and checking all valid months if required. Furthermore, we can improve this with the new switch syntax from Java 12:

return switch (month) {
    case OCTOBER, NOVEMBER, DECEMBER -> true;
    default -> false;
};

Finally, we can do some testing to validate values in or not in the range:

assertTrue(switchMonth(monthIn()));
assertFalse(switchMonth(monthNotIn()));

5. Use Collections

We can use a collection to group what satisfies the if condition and check if a value belongs to it:

Set<Month> months = Set.of(OCTOBER, NOVEMBER, DECEMBER);

Let’s add some logic to see if the set contains a specific value:

boolean contains(Month month) {
    if (months.contains(month)) {
        return true;
    }
    return false;
}

Likewise, we can add some unit tests:

assertTrue(contains(monthIn()));
assertFalse(contains(monthNotIn()));

6. Use Functional Programming

We can use functional programming to convert the if / else logic to a function. Following this approach, we will have a predictable usage of our method syntax.

6.1. Simple Predicate

Let’s still use the contains() method. However, we make it a lambda expression using a Predicate this time:

Predicate<Month> collectionPredicate = this::contains;

We are now sure that the Predicate is immutable with no intermediate variables. Its outcome is predictable and reusable in other contexts if we need to.

Let’s check it out using the test() method:

assertTrue(collectionPredicate.test(monthIn()));
assertFalse(collectionPredicate.test(monthNotIn()));

6.2. Predicate Chain

We can chain multiple Predicate adding our logic in an or condition:

Predicate<Month> orPredicate() {
    Predicate<Month> predicate = x -> x == OCTOBER;
    Predicate<Month> predicate1 = x -> x == NOVEMBER;
    Predicate<Month> predicate2 = x -> x == DECEMBER;

    return predicate.or(predicate1).or(predicate2);
}

We can then plug it in the if:

boolean predicateWithIf(Month month) {
    if (orPredicate().test(month)) {
        return true;
    }
    return false;
}

Let’s check this is working with a test:

assertTrue(predicateWithIf(monthIn()));
assertFalse(predicateWithIf(monthNotIn()));

6.3. Predicate in Streams

Similarly, we can use a Predicate in a Stream filter. Likewise, a lambda expression in a filter will replace and enhance the if logic. The if will eventually disappear. This is an advantage of functional programming while still keeping good performance and readability.

Let’s test this while parsing an input list of months:

List<Month> monthList = List.of(monthIn(), monthIn(), monthNotIn());

monthList.stream()
  .filter(this::contains)
  .forEach(m -> assertThat(m, is(in(months))));

We could also use the predicateWithIf() instead of the contains(). A lambda has no restrictions if it supports the method signature. For instance, it could be a static method.

7. Conclusion

In this tutorial, we learned how to improve the readability of multiple conditions in an if statement. We saw how to use a switch instead. Furthermore, we’ve also seen how to use a collection to check whether it contains a value. Finally, we saw how to adopt a functional approach using lambda expression. Predicate and Stream are less error-prone and will enhance code readability and maintenance.