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:

Operator	Description	Example	Output
+	Unary plus (indicates positive value)	+a	Positive value of a
-	Unary minus (negates an expression)	-a	Negative value of a
++	Increment (increases value by 1)	++a or a++	Increments a by 1
--	Decrement (decreases value by 1)	--a or a--	Decrements a by 1
!	Logical complement (inverts a boolean)	!b	Inverts the value of b

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.