Java Unary Operators

Introduction

Unary operators in Java are operators that operate on a single operand to perform various operations such as incrementing/decrementing a value, negating an expression, or inverting the value of a boolean. These operators are simple but powerful tools that are commonly used in programming for manipulating variables.

Key Points:

• Single Operand: Unary operators operate on only one operand.
• Multiple Operations: They include incrementing/decrementing, negation, and logical complement.
• Common Usage: Often used in loops, conditional statements, and simple arithmetic operations.

List of Unary Operators

Java provides the following unary operators:

Detailed Examples of Unary Operators

Let’s explore each unary operator with examples.

1. Unary Plus (+)

The unary plus operator + indicates that the value of the operand is positive. While it doesn’t change the value of the operand, it can be used for code clarity.

public class UnaryPlusExample {
    public static void main(String[] args) {
        int a = 5;
        int positiveA = +a;  // Unary plus, keeps a positive

        System.out.println("Positive value of a: " + positiveA);  // Output: Positive value of a: 5
    }
}

Explanation:

• Unary Plus: The + operator is used to indicate that a is positive, though it doesn’t change the value.

Output:

Positive value of a: 5

2. Unary Minus (-)

The unary minus operator - negates the value of the operand, converting a positive value to negative and vice versa.

public class UnaryMinusExample {
    public static void main(String[] args) {
        int a = 5;
        int negativeA = -a;  // Unary minus, negates the value of a

        System.out.println("Negative value of a: " + negativeA);  // Output: Negative value of a: -5
    }
}

Explanation:

• Unary Minus: The - operator negates the value of a, changing it from positive to negative.

Output:

Negative value of a: -5

3. Increment (++)

The increment operator ++ increases the value of its operand by 1. It can be used in two forms:

• Prefix Increment (++a): Increments the value of a before using it in an expression.
• Postfix Increment (a++): Uses the current value of a in an expression and then increments it.

public class IncrementExample {
    public static void main(String[] args) {
        int a = 5;
        int prefixIncrement = ++a;  // Prefix increment
        System.out.println("Prefix increment: " + prefixIncrement);  // Output: Prefix increment: 6

        a = 5;
        int postfixIncrement = a++;
        System.out.println("Postfix increment (before increment): " + postfixIncrement);  // Output: Postfix increment (before increment): 5
        System.out.println("Value of a after postfix increment: " + a);  // Output: Value of a after postfix increment: 6
    }
}

Explanation:

• Prefix Increment: ++a increments a first and then returns the incremented value.
• Postfix Increment: a++ returns the current value of a and then increments it.

Output:

Prefix increment: 6
Postfix increment (before increment): 5
Value of a after postfix increment: 6

4. Decrement (–)

The decrement operator -- decreases the value of its operand by 1. Like the increment operator, it has two forms:

• Prefix Decrement (--a): Decrements the value of a before using it in an expression.
• Postfix Decrement (a--): Uses the current value of a in an expression and then decrements it.

public class DecrementExample {
    public static void main(String[] args) {
        int a = 5;
        int prefixDecrement = --a;  // Prefix decrement
        System.out.println("Prefix decrement: " + prefixDecrement);  // Output: Prefix decrement: 4

        a = 5;
        int postfixDecrement = a--;
        System.out.println("Postfix decrement (before decrement): " + postfixDecrement);  // Output: Postfix decrement (before decrement): 5
        System.out.println("Value of a after postfix decrement: " + a);  // Output: Value of a after postfix decrement: 4
    }
}

Explanation:

• Prefix Decrement: --a decrements a first and then returns the decremented value.
• Postfix Decrement: a-- returns the current value of a and then decrements it.

Output:

Prefix decrement: 4
Postfix decrement (before decrement): 5
Value of a after postfix decrement: 4

5. Logical Complement (!)

The logical complement operator ! inverts the value of a boolean expression. If the expression is true, it becomes false, and vice versa.

public class LogicalComplementExample {
    public static void main(String[] args) {
        boolean b = true;
        boolean notB = !b;  // Logical complement

        System.out.println("b: " + b);        // Output: b: true
        System.out.println("notB: " + notB);  // Output: notB: false
    }
}

Explanation:

• Logical Complement: The ! operator inverts the value of b. If b is true, !b becomes false.

Output:

b: true
notB: false

Conclusion

Java’s unary operators are essential tools for manipulating single operands. They are commonly used in loops, conditionals, and arithmetic operations, providing a simple yet powerful way to perform various tasks.

Summary:

• Unary Plus (+): Indicates a positive value, although it doesn’t change the operand.
• Unary Minus (-): Negates the operand, turning a positive value into a negative one, and vice versa.
• Increment (++): Increases the value of the operand by 1. Can be used as a prefix or postfix.
• Decrement (--): Decreases the value of the operand by 1. Can be used as a prefix or postfix.
• Logical Complement (!): Inverts the value of a boolean operand.