Ternary Operator (Java)

// Basic syntax
// Returns value_if_true when the condition is true, value_if_false when false
variable = condition ? value_if_true : value_if_false;

// Correspondence with if / else
// The following two are equivalent

// Written with if / else
if (condition) {
    variable = value_if_true;
} else {
    variable = value_if_false;
}

// Written with the ternary operator
variable = condition ? value_if_true : value_if_false;

// Can be passed directly as a method argument
System.out.println(condition ? "when true" : "when false");

// Can be used as a return value
return condition ? value_if_true : value_if_false;

TernaryBasic.java

public class TernaryBasic {
    public static void main(String[] args) {

        // --- Basic ternary operator ---
        // Determines the grade based on whether cursedEnergy is 1000 or above
        int cursedEnergy = 1500;

        // Written with if / else
        String gradeIf;
        if (cursedEnergy >= 1000) {
            gradeIf = "Upper grade";
        } else {
            gradeIf = "General grade";
        }
        System.out.println("if/else: " + gradeIf);

        // Written with the ternary operator (same result)
        String gradeTernary = cursedEnergy >= 1000 ? "Upper grade" : "General grade";
        System.out.println("Ternary: " + gradeTernary); // Prints "Upper grade"

        // --- Passing directly as a method argument ---
        // Can be passed straight to println without assigning to a variable
        boolean hasDomain = false;
        System.out.println("Domain expansion: " + (hasDomain ? "Available" : "Not learned")); // Prints "Not learned"

        // --- Using in a return statement ---
        System.out.println(getStatusLabel("虎杖悠仁", 1800));
        System.out.println(getStatusLabel("釘崎野薔薇", 600));

        // --- Example where type compatibility is required ---
        // The true and false values must be the same type (or a castable type)
        int hp = 50;
        // The following is fine because both sides are String
        String hpStatus = hp > 0 ? "Alive" : "Incapacitated";
        System.out.println("HP status: " + hpStatus); // Prints "Alive"
    }

    // A method that uses the ternary operator in a return statement
    static String getStatusLabel(String name, int energy) {
        return energy >= 1000 ? name + " is a high-grade sorcerer." : name + " is a general-grade sorcerer.";
    }
}

javac TernaryBasic.java
java TernaryBasic
if/else: Upper grade
Ternary: Upper grade
Domain expansion: Not learned
虎杖悠仁 is a high-grade sorcerer.
釘崎野薔薇 is a general-grade sorcerer.
HP status: Alive

TernaryNested.java

public class TernaryNested {
    public static void main(String[] args) {

        // --- Nested ternary operator (note: readability decreases) ---
        // Example that returns a grade name from an integer representing a sorcerer's grade
        // Nesting makes the expression long and takes time to parse
        int grade = 2;

        // Nested ternary operator (low-readability style)
        String gradeName = grade == 1 ? "Grade 1 (Nanami Kento level)"
                         : grade == 2 ? "Grade 2 (Yuji Itadori level)"  // This branch is selected
                         : grade == 3 ? "Grade 3"
                         : grade == 4 ? "Grade 4"
                         : "Special grade 1 or unknown";
        System.out.println("Grade: " + gradeName);

        // The above becomes more readable with a switch expression (Java 14+)
        String gradeNameSwitch = switch (grade) {
            case 1 -> "Grade 1 (Nanami Kento level)";
            case 2 -> "Grade 2 (Yuji Itadori level)"; // This branch is selected
            case 3 -> "Grade 3";
            case 4 -> "Grade 4";
            default -> "Special grade 1 or unknown";
        };
        System.out.println("Grade (switch expression): " + gradeNameSwitch);

        // --- Best practice: limit the ternary operator to simple two-way branches ---
        // For three or more branches, if/else or a switch expression is commonly preferred
        boolean isSorcerer = true;
        String role = isSorcerer ? "Sorcerer" : "Civilian";
        System.out.println("Role: " + role); // Prints "Sorcerer"
    }
}

javac TernaryNested.java
java TernaryNested
Grade: Grade 2 (Yuji Itadori level)
Grade (switch expression): Grade 2 (Yuji Itadori level)
Role: Sorcerer

TernaryOptional.java

import java.util.Optional;

public class TernaryOptional {
    public static void main(String[] args) {

        // --- Ternary operator vs. Optional.ofNullable ---
        // Comparing approaches for handling potentially null values

        // Example where a sorcerer's nickname may be null
        String nickname = null; // Assume Gojo Satoru's nickname is not set

        // Using the ternary operator for a null check
        String displayNameTernary = nickname != null ? nickname : "No nickname";
        System.out.println("Ternary: " + displayNameTernary); // Prints "No nickname"

        // Using Optional.ofNullable
        // Wraps a potentially null value in an Optional and specifies a default with orElse
        String displayNameOptional = Optional.ofNullable(nickname).orElse("No nickname");
        System.out.println("Optional: " + displayNameOptional); // Prints "No nickname"

        // --- Behavior when a value is present ---
        String existingNickname = "The Strongest";
        String result1 = existingNickname != null ? existingNickname : "No nickname";
        String result2 = Optional.ofNullable(existingNickname).orElse("No nickname");
        System.out.println("Ternary (value present): " + result1); // Prints "The Strongest"
        System.out.println("Optional (value present): " + result2);   // Prints "The Strongest"

        // --- Advantages of using Optional ---
        // orElseGet enables lazy evaluation of the default value (useful when generating a default is costly)
        String lazyDefault = Optional.ofNullable(nickname)
            .orElseGet(() -> "Fetching nickname from DB (lazy evaluation)");
        System.out.println("orElseGet: " + lazyDefault);

        // map allows safe chaining of transformations (no exception if the value is null)
        Optional.ofNullable(existingNickname)
            .map(s -> "<" + s + ">")
            .ifPresent(s -> System.out.println("Decorated: " + s)); // Prints "<The Strongest>"
    }
}

javac TernaryOptional.java
java TernaryOptional
Ternary: No nickname
Optional: No nickname
Ternary (value present): The Strongest
Optional (value present): The Strongest
orElseGet: Fetching nickname from DB (lazy evaluation)
Decorated: <The Strongest>

Because the ternary operator is an "expression," it allows variable assignment, passing to method arguments, and returning a value with return in a single line — something that if / else statements cannot do directly. If the types of the true and false values are incompatible, the code will either fail to compile or undergo an unintended type conversion. For example, mixing int and String as in true ? 1 : "text" results in a compile error.

Nested ternary operators become difficult to follow, so when you have three or more branches, using if / else if or a switch expression (Java 14+) improves maintainability. For details on switch expressions, see switch statement / switch expression.

For null checks, you can use either the ternary operator (value != null ? value : default) or Optional.ofNullable(value).orElse(default). For a simple null replacement, the ternary operator is sufficient, but when you need value transformation (map) or lazy evaluation (orElseGet), Optional is a better fit. For details on Optional, see Optional.