Java Ternary Operator

Some decisions are so small that a full if else block feels like overkill: show "item" or "items", pick the lower price, label a product "In stock" or "Sold out". For these, Java gives you the ternary operator, written ? :. In this lesson, you'll learn how the Java ternary operator works, where it makes code cleaner, and when an ordinary if else is the better choice.

What is the ternary operator in Java?

The ternary operator is the only Java operator that takes three operands (that's what "ternary" means). It checks a boolean condition and evaluates to one of two values:

condition ? valueIfTrue : valueIfFalse

Read it as a question: "Is the condition true? If yes, use the first value; if not, use the second." The whole thing is an expression, which means it produces a value you can store, print or pass along.

public class StockLabel {
    public static void main(String[] args) {
        int stock = 0;

        String label = stock > 0 ? "In stock" : "Sold out";

        System.out.println("Wireless mouse: " + label);
    }
}

Wireless mouse: Sold out

Ternary operator vs if else

Any ternary can be rewritten as an if else. These two programs do exactly the same thing: find the cheaper of two flight prices.

public class CheaperFlightIf {
    public static void main(String[] args) {
        int airlineA = 189;
        int airlineB = 174;
        int cheapest;

        if (airlineA < airlineB) {
            cheapest = airlineA;
        } else {
            cheapest = airlineB;
        }

        System.out.println("Cheapest fare: $" + cheapest);
    }
}

Cheapest fare: $174

public class CheaperFlight {
    public static void main(String[] args) {
        int airlineA = 189;
        int airlineB = 174;

        int cheapest = airlineA < airlineB ? airlineA : airlineB;

        System.out.println("Cheapest fare: $" + cheapest);
    }
}

Cheapest fare: $174

The ternary version replaces six lines with one, and the variable can be assigned in the same line it's declared. That's the sweet spot: choosing one of two values.

Using the ternary operator inside other expressions

Because it's an expression, a ternary can sit right inside a println or a calculation. A favorite use is getting singular and plural words right:

public class CartSummary {
    public static void main(String[] args) {
        int itemCount = 1;
        System.out.println("Your cart has " + itemCount + (itemCount == 1 ? " item" : " items"));

        itemCount = 3;
        System.out.println("Your cart has " + itemCount + (itemCount == 1 ? " item" : " items"));
    }
}

Your cart has 1 item
Your cart has 3 items

Notice the parentheses around the ternary. They matter, as you'll see in the common mistakes below.

Here's a ternary inside a calculation, giving members a 10% discount:

public class MemberPrice {
    public static void main(String[] args) {
        double price = 40.0;
        boolean isMember = true;

        double finalPrice = price * (isMember ? 0.90 : 1.0);

        System.out.println("You pay: $" + finalPrice);
    }
}

You pay: $36.0

Can you nest ternary operators?

Yes. The value after ? or : can itself be another ternary. Put each branch on its own line so the structure is visible:

public class WeatherLabel {
    public static void main(String[] args) {
        int celsius = 17;

        String feel = celsius >= 25 ? "hot"
                    : celsius >= 15 ? "mild"
                    : "cold";

        System.out.println("At " + celsius + " degrees it feels " + feel);
    }
}

At 17 degrees it feels mild

This reads like an else if chain: hot if 25 or more, otherwise mild if 15 or more, otherwise cold. Two levels are about the limit. Beyond that, readers have to untangle the colons in their heads, and a plain if else chain or a switch is kinder.

What types can the two values have?

Both values should be the same type, or types Java can combine. If you mix an int and a double, Java promotes the result to double, even when the int branch is chosen. This surprises many beginners:

public class TernaryTypes {
    public static void main(String[] args) {
        boolean wholeNumber = true;

        System.out.println(wholeNumber ? 5 : 2.5);
    }
}

5.0

The condition was true, so Java chose 5, but the type of the whole expression is double, so it prints 5.0. And if you try to store a mixed ternary in an int, such as int x = ok ? 5 : 2.5;, the compiler refuses with "possible lossy conversion from double to int".

When should you avoid the ternary operator?

• When you need actions, not values. A ternary must produce a value. A line like ok ? System.out.println("yes") : System.out.println("no"); doesn't compile ("not a statement"). Use if else for actions.
• When branches are long. If either value is a long calculation, the line becomes unreadable.
• When nesting goes deeper than two levels.

Real-world example: a game scoreboard

Here, small ternaries keep a scoreboard message tidy without a forest of if blocks:

public class Scoreboard {
    public static void main(String[] args) {
        String player = "Mia";
        int score = 1450;
        int highScore = 1200;
        int lives = 1;

        int newHighScore = score > highScore ? score : highScore;
        String badge = score > highScore ? "NEW RECORD!" : "Keep going";

        System.out.println(player + ": " + score + " points (" + badge + ")");
        System.out.println("High score: " + newHighScore);
        System.out.println(lives + (lives == 1 ? " life" : " lives") + " left");
    }
}

Mia: 1450 points (NEW RECORD!)
High score: 1450
1 life left

Common mistakes with the Java ternary operator

1. Forgetting parentheses next to +

The + operator has higher precedence than ? :. Without parentheses, Java glues the text and number together first:

System.out.println("Items: " + count == 1 ? "one" : "many");

Java reads this as ("Items: " + count) == 1, comparing a String with a number, and the compiler stops with "bad operand types for binary operator". Wrap the ternary in parentheses: "Items: " + (count == 1 ? "one" : "many").

2. Using it as a statement

A ternary on its own line that just calls println on each side won't compile. The ternary chooses values; if else chooses actions.

3. Comparing Strings with == in the condition

The condition follows the same rules as in if: write name.equals("admin") ? ... : ..., not name == "admin".

4. Deep nesting

Three or more nested ternaries on one line are a puzzle, not code. Refactor to if else.

Practice exercise

public class ParkingFee {
    public static void main(String[] args) {
        int hours = 4;

        double fee = hours <= 1 ? 0.0 : (hours - 1) * 2.50;

        System.out.println("Parking fee: $" + fee);
        System.out.println(fee == 0.0 ? "Free parking!" : "Please pay at the machine.");
    }
}

Parking fee: $7.5
Please pay at the machine.

What's next?

You can now make decisions with if else, switch and the ternary operator. Next, you'll make your programs repeat work automatically with the Java for loop.