Page History

The conditional operator ?: uses the boolean value of its first operand to decide which of the other two expressions will be evaluated. (See §15.25, "Conditional Operator ? :" of the Java Language Specification (JLS) [JLS 20112013].)

The general form of a Java conditional expression is operand1 ? operand2 : operand3.

...

The conditional operator is syntactically right-associative. For example, a?b:c?d:e?f:g is equivalent to a?b:(c?d:(e?f:g)).

The Java Language Specification JLS rules for determining the result type of a conditional expression (see following table) are complicated; programmers could be surprised by the type conversions required for expressions they have written.

Result type determination begins from the top of the table; the compiler applies the first matching rule. The Operand 2 and Operand 3 columns refer to operand2 and operand3 (from the previous definition) respectively. In the table, constant int refers to constant expressions of type int (such as '0' or variables declared final).

For the final table row, S1 and S2 are the types of the second and third operands respectively. T1 is the type that results from applying boxing conversion to S1, and T2 is the type that results from applying boxing conversion to S2. The type of the conditional expression is the result of applying capture conversion to S2. The type of the conditional expression is the result of applying capture conversion to the least upper bound of T1 and T2. See §5.1.7, "Boxing Conversion," §5.1.10, "Capture Conversion," and §15.12.2.7, "Inferring Type Arguments Based on Actual Arguments," of the JLS for additional information [JLS 2013].

Determining the Result Type of a Conditional Expression

See §5.1.7, "Boxing Conversion," §5.1.10, "Capture Conversion," and §15.12.2.7, "Inferring Type Arguments Based on Actual Arguments," of the Java Language Specification for additional information on the final table entry.

The complexity of the rules that determine the result type of a conditional expression can lead to unintended type conversions. Consequently, the second and third operands of each conditional expression should have identical types. This recommendation also applies to boxed primitives.

...

In this noncompliant code example, the programmer expects that both print statements will print the value of alpha as a char—A:

public class Expr {
  public static void main(String[] args) {
    char alpha = 'A';
    int i = 0;
    // Other code. Value of i may change 
    boolean trueExp = true; // Some expression that evaluates to true
    System.out.print(trueExp ? alpha : 0); // prints A
    System.out.print(trueExp ? alpha : i); // prints 65
  }
}

...

public class Expr {
  public static void main(String[] args) {
    char alpha = 'A';
    int i = 0;
    boolean trueExp = true; // SomeExpression expression that evaluates to true
    System.out.print(trueExp ? alpha : ((char) 0)); // printsPrints A
    // Deliberate narrowing cast of i; possible truncation OK
    System.out.print(trueExp ? alpha : ((char) i)); // printsPrints A
  }
}

Note that the explicit cast in the first conditional expression is redundant; that is, the value printed remains identical whether the cast is present or absent. Nevertheless, use of the redundant cast is good practice; it serves as an explicit indication of the programmer's intent and consequently improves maintainability. When the value of i in the second conditional expression falls outside the range that can be represented as a char, the explicit cast will truncate its value. This usage complies with exception NUM12-EX0 of NUM12-J. Ensure conversions of numeric types to narrower types do not result in lost or misinterpreted data.

...

public class ShortSet {
  public static void main(String[] args) {
    HashSet<Short> s = new HashSet<Short>();
    for (short i = 0; i < 100; i++) {
      s.add(i);
      // Cast of i-1 is safe, because value is always representable
      Short workingVal = (short) (i-1);
      // ... otherOther code may update workingVal

      s.remove(((i % 2) == 1) ? i-1 : workingVal);
    }
    System.out.println(s.size());
  }
}

...

public class ShortSet {
  public static void main(String[] args) {
    HashSet<Short> s = new HashSet<Short>();
    for (short i = 0; i < 100; i++) {
      s.add(i);
      // Cast of i-1 is safe, because the resulting value is always representable
      Short workingVal = (short) (i-1);
      // ... otherOther code may update workingVal

      // Cast of i-1 is safe, because the resulting value is always representable
      s.remove(((i % 2) == 1) ? Short.valueOf((short) (i-1)) : workingVal);
    }
    System.out.println(s.size());
  }
}

ConsequentlyAs a result of the cast, the second and third operands of the conditional expression both have type Short, and the remove() call has the expected result.

...

...