Ternary Operator in Java

1. Overview

The ternary conditional operator ?: allows us to define expressions in Java. It’s a condensed form of the if-else statement that also returns a value.

In this tutorial, we’ll learn when and how to use a ternary construct. We’ll start by looking at its syntax and then explore its usage.

2. Syntax

The ternary operator ?: in Java is the only operator that accepts three operands:

booleanExpression ? expression1 : expression2

The very first operand must be a boolean expression, and the second and third operands can be any expression that returns some value. The ternary construct returns expression1 as an output if the first operand evaluates to true, expression2 otherwise.

3. Ternary Operator Example

Let’s consider this if-else construct:

int num = 8;
String msg = "";
if(num > 10) {
    msg = "Number is greater than 10";
}
else {
    msg = "Number is less than or equal to 10";
}

Here we have assigned a value to msg based on the conditional evaluation of num.

We can make this code more readable and safe by easily replacing the if-else statement with a ternary construct:

final String msg = num > 10 
  ? "Number is greater than 10" 
  : "Number is less than or equal to 10";

4. Expression Evaluation

When using a Java ternary construct, only one of the right-hand side expressions, i.e. either expression1 or expression2, is evaluated at runtime.

We can test that out by writing a simple JUnit test case:

@Test
public void whenConditionIsTrue_thenOnlyFirstExpressionIsEvaluated() {
    int exp1 = 0, exp2 = 0;
    int result = 12 > 10 ? ++exp1 : ++exp2;
    
    assertThat(exp1).isEqualTo(1);
    assertThat(exp2).isEqualTo(0);
    assertThat(result).isEqualTo(1);
}

Our boolean expression 12 > 10 always evaluates to true, so the value of exp2 remained as-is.

Similarly, let’s consider what happens for a false condition:

@Test
public void whenConditionIsFalse_thenOnlySecondExpressionIsEvaluated() {
    int exp1 = 0, exp2 = 0;
    int result = 8 > 10 ? ++exp1 : ++exp2;

    assertThat(exp1).isEqualTo(0);
    assertThat(exp2).isEqualTo(1);
    assertThat(result).isEqualTo(1);
}

The value of exp1 remained untouched, and the value of exp2 was incremented by 1.

5. Nesting Ternary Operator

It’s possible for us to nest our ternary operator to any number of levels of our choice.

So, this construct is valid in Java:

String msg = num > 10 ? "Number is greater than 10" : 
  num > 5 ? "Number is greater than 5" : "Number is less than equal to 5";

To improve the readability of the above code, we can use braces () wherever necessary:

String msg = num > 10 ? "Number is greater than 10" 
  : (num > 5 ? "Number is greater than 5" : "Number is less than equal to 5");

However**,** please note that it’s not recommended to use such deeply nested ternary constructs in the real world. This is because it makes the code less readable and difficult to maintain.

6. Conclusion

In this quick article, we learned about the ternary operator in Java. It isn’t possible to replace every if-else construct with a ternary operator. But it’s a great tool for some cases and makes our code much shorter and more readable.

As usual, the entire source code is available over on GitHub.