Unary operators in Java

Introduction

Unary operators help you change or check a single value quickly. They make your code shorter and easier to read.

When you want to increase or decrease a number by one, like counting steps.

When you want to flip a true/false value, like turning a light on or off.

When you want to get the positive or negative sign of a number.

When you want to check if a value is true or false in conditions.

When you want to simplify expressions by using shorthand operators.

Syntax

Java

++variable;  // increase by 1
--variable;  // decrease by 1
+variable;   // positive sign (usually no change)
-variable;   // negative sign (negates the value)
!boolean;    // logical NOT (flips true/false)

++ and -- can be used before (prefix) or after (postfix) a variable.

Logical NOT (!) only works with boolean values.

Examples

Prefix ++ increases a by 1 before using it.

Java

int a = 5;
++a;  // a becomes 6

Postfix -- decreases b by 1 after using it.

Java

int b = 5;
b--;  // b becomes 4

Logical NOT flips false to true.

Java

boolean lightOn = false;
lightOn = !lightOn;  // lightOn becomes true

Unary minus changes sign of c.

Java

int c = -10;
int d = -c;  // d becomes 10

Sample Program

This program shows how unary operators ++, --, !, and unary minus work. It prints values before and after applying these operators.

Java

public class UnaryOperatorsDemo {
    public static void main(String[] args) {
        int count = 10;
        System.out.println("Original count: " + count);

        System.out.println("Using prefix ++: " + (++count));
        System.out.println("After prefix ++, count: " + count);

        System.out.println("Using postfix --: " + (count--));
        System.out.println("After postfix --, count: " + count);

        boolean isActive = false;
        System.out.println("Original isActive: " + isActive);
        System.out.println("After !isActive: " + !isActive);

        int number = -5;
        System.out.println("Original number: " + number);
        System.out.println("Unary minus applied: " + (-number));
    }
}

Important Notes

Prefix ++/-- changes the value before using it in an expression.

Postfix ++/-- changes the value after using it in an expression.

Unary plus (+) usually does not change the value but can be used for clarity.

Summary

Unary operators work on one value to change or check it.

Use ++ and -- to add or subtract one quickly.

Use ! to flip true/false values.

Practice

1.

What does the unary operator ++ do in Java?

easy

A. Negates the value of a variable

B. Increases the value of a variable by 1

C. Decreases the value of a variable by 1

D. Checks if a value is true or false

Solution

1. Step 1: Understand the meaning of ++

   The ++ operator adds 1 to the current value of a variable.

2. Step 2: Compare with other unary operators

   -- subtracts 1, ! flips boolean, and negation changes sign.

3. Final Answer:

   Increases the value of a variable by 1 -> Option B

4. Quick Check:

   ++ means add one [OK]

Hint: ++ means add one to a number quickly [OK]

Common Mistakes:

• Confusing ++ with --
• Thinking ++ negates the value
• Mixing ++ with boolean negation !

2.

Which of the following is the correct **postfix** syntax to decrement a variable x by 1 using a unary operator?

int x = 5;
// Your code here

easy

A. x-1;

B. --x;

C. x--;

D. x=!1;

Solution

1. Step 1: Identify decrement unary operators

   Both x-- and --x decrement by 1, but x-1 is an expression, not an operator.

2. Step 2: Choose correct syntax for decrement

   x--; correctly decreases x by 1 after its current use.

3. Final Answer:

   x--; -> Option C

4. Quick Check:

   Use x-- to subtract one [OK]

Hint: Use x-- or --x to subtract one [OK]

Common Mistakes:

• Using x-1; which doesn't change x
• Confusing ! operator with decrement
• Writing invalid syntax like x=!1;

3.

What is the output of the following Java code?

int a = 3;
System.out.println(++a);
System.out.println(a++);
System.out.println(a);

medium

A. 4 4 5

B. 3 4 5

C. 4 3 4

D. 3 3 4

Solution

1. Step 1: Evaluate ++a

   ++a increases a before printing, so prints 4 and a becomes 4.

2. Step 2: Evaluate a++

   a++ prints current a (4) then increases it to 5.

3. Step 3: Print final value of a

   After previous steps, a is 5, so prints 5.

4. Final Answer:

   4 4 5 -> Option A

5. Quick Check:

   Prefix ++ adds before print, postfix ++ adds after print [OK]

Hint: Prefix ++ changes before print, postfix ++ after print [OK]

Common Mistakes:

• Mixing prefix and postfix effects
• Forgetting that ++ changes the variable
• Assuming no change in variable after print

4.

Find the error in the following code snippet:

boolean flag = true;
flag = !flag++;
System.out.println(flag);

medium

A. No error, code runs fine

B. Missing semicolon after flag declaration

C. Logical NOT operator ! cannot be used here

D. Cannot apply ++ to a boolean variable

Solution

1. Step 1: Check variable type and operators

   flag is boolean; ++ operator works only on numeric types, not boolean.

2. Step 2: Identify invalid operation

   Using flag++ causes a compile-time error because booleans cannot be incremented.

3. Final Answer:

   Cannot apply ++ to a boolean variable -> Option D

4. Quick Check:

   ++ works only on numbers, not booleans [OK]

Hint: ++ cannot be used on boolean variables [OK]

Common Mistakes:

• Trying to increment boolean values
• Confusing logical NOT ! with increment ++
• Assuming code compiles without error

5.

Given the code below, what will be the final value of count after execution?

int count = 0;
for (int i = 0; i < 3; i++) {
    count = count++ + ++count;
}
System.out.println(count);

hard

A. 14

B. 6

C. 12

D. 9

Solution

1. Step 1: Understand count = count++ + ++count; behavior

   Binary + evaluates left operand first (count++: old value then increment), then right (++count: increment then new value).

2. Step 2: Trace loop iterations

   Iteration 1 (count=0): count++ value=0 (count=1), ++count value=2, sum=2 -> count=2.
   Iteration 2 (count=2): count++=2 (count=3), ++count=4, sum=6 -> count=6.
   Iteration 3 (count=6): count++=6 (count=7), ++count=8, sum=14 -> count=14.

3. Step 3: Final value after loop

   After 3 iterations, count is 14.

4. Final Answer:

   14 -> Option A

5. Quick Check:

   Left-to-right: postfix old + prefix new [OK]

Hint: Left operand postfix (old then inc), right prefix (inc then new) [OK]

Common Mistakes:

• Assuming both increments add fully
• Ignoring postfix increment side effects
• Calculating sum without assignment effect