Java provides a rich set of operators to manipulate variables. We can divide all the Java operators into the following groups −
- Arithmetic Operators
- Relational Operators
- Bitwise Operators
- Logical Operators
- Assignment Operators
- Misc Operators
The Arithmetic Operators
|
Operator |
Description |
Example |
|
+ (Addition) |
Adds values on either side of the operator. |
A + B will give 30 |
|
– (Subtraction) |
Subtracts right-hand operand from left-hand operand. |
A – B will give -10 |
|
* (Multiplication) |
Multiplies values on either side of the operator. |
A * B will give 200 |
|
/ (Division) |
Divides left-hand operand by right-hand operand. |
B / A will give 2 |
|
% (Modulus) |
Divides left-hand operand by right-hand operand and returns remainder. |
B % A will give 0 |
|
++ (Increment) |
Increases the value of operand by 1. |
B++ gives 21 |
|
— (Decrement) |
Decreases the value of operand by 1. |
B– gives 19 |
public class Test1 {
public static void main(String args[]) {
int a = 10,b=20,c=25,d=25;
System.out.println(“a + b = ” + (a + b) );
System.out.println(“a – b = ” + (a – b) );
System.out.println(“a * b = ” + (a * b) );
System.out.println(“b / a = ” + (b / a) );
System.out.println(“b % a = ” + (b % a) );
System.out.println(“c % a = ” + (c % a) );
System.out.println(“a++ = ” + (a++) );
System.out.println(“b– = ” + (a–) );
System.out.println(“d++ = ” + (d++) );
System.out.println(“++d = ” + (++d) );
}
}
Relational Operators
|
Operator |
Description |
Example |
|
== (equal to) |
Checks if the values of two operands are equal or not, if yes then condition becomes true. |
(A == B) is not true. |
|
!= (not equal to) |
Checks if the values of two operands are equal or not, if values are not equal then condition becomes true. |
(A != B) is true. |
|
> (greater than) |
Checks if the value of left operand is greater than the value of right operand, if yes then condition becomes true. |
(A > B) is not true. |
|
< (less than) |
Checks if the value of left operand is less than the value of right operand, if yes then condition becomes true. |
(A < B) is true. |
|
>= (greater than or equal to) |
Checks if the value of left operand is greater than or equal to the value of right operand, if yes then condition becomes true. |
(A >= B) is not true. |
|
<= (less than or equal to) |
Checks if the value of left operand is less than or equal to the value of right operand, if yes then condition becomes true. |
(A <= B) is true. |
public class Test2 {
public static void main(String args[]) {
int a = 10;
int b = 20;
System.out.println(“a == b = ” + (a == b) );
System.out.println(“a != b = ” + (a != b) );
System.out.println(“a > b = ” + (a > b) );
System.out.println(“a < b = ” + (a < b) );
System.out.println(“b >= a = ” + (b >= a) );
System.out.println(“b <= a = ” + (b <= a) );
}
}
Bitwise Operators
Java defines several bitwise operators, which can be applied to the integer types, long, int, short, char, and byte.
Bitwise operator works on bits and performs bit-by-bit operation. Assume if a = 60 and b = 13; now in binary format they will be as follows −
a = 0011 1100
b = 0000 1101
—————–
a&b = 0000 1100
a|b = 0011 1101
a^b = 0011 0001
~a = 1100 0011
The following table lists the bitwise operators −
Assume integer variable A holds 60 and variable B holds 13 then −
|
Operator |
Description |
Example |
|
& (bitwise and) |
Binary AND Operator copies a bit to the result if it exists in both operands. |
(A & B) will give 12 which is 0000 1100 |
|
| (bitwise or) |
Binary OR Operator copies a bit if it exists in either operand. |
(A | B) will give 61 which is 0011 1101 |
|
^ (bitwise XOR) |
Binary XOR Operator copies the bit if it is set in one operand but not both. |
(A ^ B) will give 49 which is 0011 0001 |
|
~ (bitwise compliment) |
Binary Ones Complement Operator is unary and has the effect of ‘flipping’ bits. |
(~A ) will give -61 which is 1100 0011 in 2’s complement form due to a signed binary number. |
|
<< (left shift) |
Binary Left Shift Operator. The left operands value is moved left by the number of bits specified by the right operand. |
A << 2 will give 240 which is 1111 0000 |
|
>> (right shift) |
Binary Right Shift Operator. The left operands value is moved right by the number of bits specified by the right operand. |
A >> 2 will give 15 which is 1111 |
|
>>> (zero fill right shift) |
Shift right zero fill operator. The left operands value is moved right by the number of bits specified by the right operand and shifted values are filled up with zeros. |
A >>>2 will give 15 which is 0000 1111 |
public class Test3 {
public static void main(String args[]) {
int a = 60; /* 60 = 0011 1100 */
int b = 13; /* 13 = 0000 1101 */
int c = 0;
c = a & b; /* 12 = 0000 1100 */
System.out.println(“a & b = ” + c );
c = a | b; /* 61 = 0011 1101 */
System.out.println(“a | b = ” + c );
c = a ^ b; /* 49 = 0011 0001 */
System.out.println(“a ^ b = ” + c );
c = ~a; /*-61 = 1100 0011 */
System.out.println(“~a = ” + c );
c = a << 2; /* 240 = 1111 0000 */
System.out.println(“a << 2 = ” + c );
c = a >> 2; /* 15 = 1111 */
System.out.println(“a >> 2 = ” + c );
c = a >>> 2; /* 15 = 0000 1111 */
System.out.println(“a >>> 2 = ” + c );
}
}
Logical Operators
The following table lists the logical operators −
Assume Boolean variables A holds true and variable B holds false, then −
|
Operator |
Description |
Example |
|
&& (logical and) |
Called Logical AND operator. If both the operands are non-zero, then the condition becomes true. |
(A && B) is false |
|
|| (logical or) |
Called Logical OR Operator. If any of the two operands are non-zero, then the condition becomes true. |
(A || B) is true |
|
! (logical not) |
Called Logical NOT Operator. Use to reverses the logical state of its operand. If a condition is true then Logical NOT operator will make false. |
!(A && B) is true |
public class Test4 {
public static void main(String args[]) {
boolean a = true;
boolean b = false;
System.out.println(“a && b = ” + (a&&b));
System.out.println(“a || b = ” + (a||b) );
System.out.println(“!(a && b) = ” + !(a && b));
}
}
Assignment Operators
Following are the assignment operators supported by Java language −
|
Operator |
Description |
Example |
|
= |
Simple assignment operator. Assigns values from right side operands to left side operand. |
C = A + B will assign value of A + B into C |
|
+= |
Add AND assignment operator. It adds right operand to the left operand and assign the result to left operand. |
C += A is equivalent to C = C + A |
|
-= |
Subtract AND assignment operator. It subtracts right operand from the left operand and assign the result to left operand. |
C -= A is equivalent to C = C – A |
|
*= |
Multiply AND assignment operator. It multiplies right operand with the left operand and assign the result to left operand. |
C *= A is equivalent to C = C * A |
|
/= |
Divide AND assignment operator. It divides left operand with the right operand and assign the result to left operand. |
C /= A is equivalent to C = C / A |
|
%= |
Modulus AND assignment operator. It takes modulus using two operands and assign the result to left operand. |
C %= A is equivalent to C = C % A |
|
<<= |
Left shift AND assignment operator. |
C <<= 2 is same as C = C << 2 |
|
>>= |
Right shift AND assignment operator. |
C >>= 2 is same as C = C >> 2 |
|
&= |
Bitwise AND assignment operator. |
C &= 2 is same as C = C & 2 |
|
^= |
bitwise exclusive OR and assignment operator. |
C ^= 2 is same as C = C ^ 2 |
|
|= |
bitwise inclusive OR and assignment operator. |
C |= 2 is same as C = C | 2 |
The ? : Operator
We have covered conditional operator ? : in the previous chapter which can be used to replace if…else statements. It has the following general form −
Exp1 ? Exp2 : Exp3;
Where Exp1, Exp2, and Exp3 are expressions. Notice the use and placement of the colon.
To determine the value of the whole expression, initially exp1 is evaluated.
- If the value of exp1 is true, then the value of Exp2 will be the value of the whole expression.
- If the value of exp1 is false, then Exp3 is evaluated and its value becomes the value of the entire expression.
Operator Precedence
Finally let’s add the &&, ||, &, | and ? operators to the precedence table
- *, /, % Multiplicative operators
- +, – Additive operators
- <, >, >=, <= Relational operators
- ==, != Then do any comparisons for equality and inequality
- & Bitwise and
- | Bitwise or
- && Logical and
- || Logical or
- ? : Conditional operator
- = Assignment operator
Recommended Articles