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. The second and third operands can be any expressions that are type-compatible with each other and with the variable where the result is used:

The ternary construct returns expression1 as an output if the first operand is evaluated to be true, and expression2 if it’s evaluated to be false. Importantly, expression1 and expression2 must be expressions that return a value, not a void statement.

An if-else statement should be used instead when we need to conditionally execute a void method.

3. Advantages of Ternary Operator

Let’s look at some advantages the ternary operator presents:

• Allows us to write an if-else statement in a single line of code, which can improve conciseness
• Enables concise initialization of final variables
• Can make code debugging easier, especially for simple conditions, because of its compactness. When debugging, having a single line of code for conditional operation can make it easier to set breakpoints and examine the result of the condition.
• Unlike the if-else block, it can be used directly in a return statement or variable initialization.

4. Ternary Operator Examples

Let’s consider an example of the 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’ve assigned a value to msg based on the conditional evaluation of num.

4.1. Basic Usage

We can make the earlier if-else construct more concise by replacing it with a ternary construct:

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

Here, we use a ternary operator to assign the appropriate value to msg based on the condition num > 10.

4.2. Usage With final Variables

The ternary operator is useful when initializing a final variable:

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

The ternary operator allows us to initialize the final variable msg with a value that depends on num. Once assigned, this value cannot be changed.

4.3. Usage in return Statements

We can use the ternary operator directly in return statements:

String checkNumber(int num) {
    return num > 10 
      ? "Number is greater than 10" 
      : "Number is less than or equal to 10";
}

In the code above, we define a method checkNumber() that accepts an int as an argument. The method uses a ternary operator in the return statement to immediately return a string based on whether num is greater than 10 or not.

4.4. Incorrect Usage

Importantly, a ternary operator cannot be used for statements that don’t return a value.

Let’s consider an if-else statement that doesn’t return a value:

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

The code above uses Logger to output a result based on num.

Now, let’s look at an incorrect attempt to convert the if-else statement to a ternary expression:

int num = 8;
num > 10 
  ? LOGGER.info("Number is greater than 10") 
  : LOGGER.info("Number is less than or equal to 10");

The code above demonstrates incorrect usage of the ternary operator because LOGGER.info() is a void method and doesn’t return a value.

5. Expression Evaluation

When using a Java ternary construct, only one of the right-hand side expressions (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);
}

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

6. Nesting Ternary Operator

We can nest our ternary operator to any number of levels of our choice.

Let’s see a quick example:

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 parentheses () 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 more difficult to maintain.

7. 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.