Operators

Operators are symbols that perform operations on variables and values.

Operators in Java can be classified into 6 categories:

1. Arithmetic Operators
2. Assignment Operators
3. Comparison/Relational Operators
4. Logical Operators
5. Unary Operators
6. Bitwise Operators

Arithmetic Operators

Arithmetic operators are used to perform arithmetic operations on variables and data.

Operator	Description	Example
+	Addition	a + b
-	Subtraction	a - b
*	Multiplication	a * b
/	Division	a / b
%	Modulus (remainder)	a % b
++	Increment	a++ or ++a
--	Decrement	a-- or --a

int sum = 5 + 3;    // 8
int diff = 5 - 3;   // 2
int product = 5 * 3; // 15
int quotient = 5 / 2; // 2 (integer division)
double exactQuotient = 5.0 / 2.0; // 2.5
int remainder = 5 % 2; // 1

int a = 5;
a++;    // a is now 6
++a;    // a is now 7 (prefix: increment then use)
a--;    // a is now 6

Assignment Operators

Assignment operators are used in Java to assign values to variables.

Operator	Description	Example	Equivalent to
=	Assignment	a = b	a = b
+=	Add and assign	a += b	a = a + b
-=	Subtract and assign	a -= b	a = a - b
*=	Multiply and assign	a *= b	a = a * b
/=	Divide and assign	a /= b	a = a / b
%=	Modulus and assign	a %= b	a = a % b

int x = 10;
x += 5;  // x = 15
x -= 3;  // x = 12
x *= 2;  // x = 24
x /= 3;  // x = 8
x %= 5;  // x = 3

Comparison/Relational Operators

Relational operators are used to check the relationship between two operands.

Operator	Description	Example
==	Equal to	a == b
!=	Not equal to	a != b
>	Greater than	a > b
<	Less than	a < b
>=	Greater than or equal to	a >= b
<=	Less than or equal to	a <= b

int a = 5;
int b = 7;
boolean isEqual = (a == b);      // false
boolean isNotEqual = (a != b);   // true
boolean isGreater = (a > b);     // false
boolean isLess = (a < b);        // true
boolean isGreaterOrEqual = (a >= b); // false
boolean isLessOrEqual = (a <= b);    // true

Logical Operators

Logical operators are used to check whether an expression is true or false.

Operator	Description	Example
&&	Logical AND	a && b
||	Logical OR	a || b
!	Logical NOT	!a

boolean a = true;
boolean b = false;

boolean andResult = a && b;  // false
boolean orResult = a || b;   // true
boolean notResult = !a;      // false

Unary Operators

Unary operators are used with only one operand.

Bitwise Operators

Bitwise operators in Java are used to perform operations on individual bits.

Operator	Description	Example
&	Bitwise AND	a & b
|	Bitwise OR	a | b
^	Bitwise XOR	a ^ b
~	Bitwise NOT	~a
<<	Left shift	a << n
>>	Right shift	a >> n
>>>	Unsigned right shift	a >>> n

int a = 5;    // 0101 in binary
int b = 3;    // 0011 in binary

int bitwiseAnd = a & b;     // 0001 -> 1
int bitwiseOr = a | b;      // 0111 -> 7
int bitwiseXor = a ^ b;     // 0110 -> 6
int bitwiseNot = ~a;        // 1010 -> -6 (in two's complement)
int leftShift = a << 1;     // 1010 -> 10
int rightShift = a >> 1;    // 0010 -> 2