Java Operators
13:22:00
Operators in Java
Java Operator is a special symbol that
tells the compiler to perform specific mathematical or logical Operation. Java
supports following lists of operators.
- Arithmetic Operators
- Relational Operators
- Logical Operators
- Bitwise Operators
- Assignment Operators
- Ternary or Conditional Operators
Arithmetic Operators
Given table shows all
the Arithmetic operator supported by Java Language. Lets suppose variable A hold 8 and B hold 3.
Operator
|
Example (int A=8, B=3)
|
Result
|
+
|
A+B
|
11
|
-
|
A-B
|
5
|
*
|
A*B
|
24
|
/
|
A/B
|
2
|
%
|
A%4
|
0
|
Relational Operators
Which can be used to
check the Condition, it always return true or false. Lets suppose variableA hold 8 and B hold 3.
Operators
|
Example (int A=8, B=3)
|
Result
|
<
|
A<B
|
False
|
<=
|
A<=10
|
True
|
>
|
A>B
|
True
|
>=
|
A<=B
|
False
|
==
|
A== B
|
False
|
!=
|
A!=(-4)
|
True
|
Logical Operator
Which can be used to
combine more than one Condition?. Suppose you want to combined two conditions A<B and B>C, then you need to use Logical
Operator like (A<B) && (B>C). Here &&is Logical Operator.
Operator
|
Example (int A=8, B=3, C=-10)
|
Result
|
&&
|
(A<B) && (B>C)
|
False
|
||
|
(B!=-C) || (A==B)
|
True
|
!
|
!(B<=-A)
|
True
|
Truth table of Logical
Operator
C1
|
C2
|
C1 && C2
|
C1 || C2
|
!C1
|
!C2
|
T
|
T
|
T
|
T
|
F
|
F
|
T
|
F
|
F
|
T
|
F
|
T
|
F
|
T
|
F
|
T
|
T
|
F
|
F
|
F
|
F
|
F
|
T
|
T
|
Assignment operators
Which can be used to
assign a value to a variable. Lets suppose variable A hold 8 and B hold 3.
Operator
|
Example (int A=8, B=3)
|
Result
|
+=
|
A+=B or A=A+B
|
11
|
-=
|
A-=3 or A=A+3
|
5
|
*=
|
A*=7 or A=A*7
|
56
|
/=
|
A/=B or A=A/B
|
2
|
%=
|
A%=5 or A=A%5
|
3
|
=a=b
|
Value of b will be assigned to 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
|
The 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
|
|
>>=
|
Bitwise
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
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
|
Miscellaneous
Operators
There are few
other operators supported by Java Language.
Conditional Operator (
? : )
Conditional
operator is also known as the ternary operator. This operator consists of
three operands and is used to evaluate Boolean expressions. The goal of the
operator is to decide, which value should be assigned to the variable. The
operator is written as −
variable x = (expression) ? value if true : value if false
Following is an
example −
Example
public class Test {
public static void main(String args[]) {
int a, b;
a = 10;
b = (a == 1) ? 20: 30;
System.out.println( "Value of b is : " + b );
b = (a == 10) ? 20: 30;
System.out.println( "Value of b is : " + b );
}
}
This will produce
the following result −
Output
Value of b is : 30
Value of b is : 20
instanceof Operator
This operator is
used only for object reference variables. The operator checks whether the
object is of a particular type (class type or interface type). instanceof
operator is written as −
( Object reference variable ) instanceof (class/interface type)
If the object
referred by the variable on the left side of the operator passes the IS-A check
for the class/interface type on the right side, then the result will be true.
Following is an example −
Example
public class Test {
public static void main(String args[]) {
String name = "James";
// following will return true since name is type of String
boolean result = name instanceof String;
System.out.println( result );
}
}
This will produce
the following result −
Output
true
This operator will
still return true, if the object being compared is the assignment compatible
with the type on the right. Following is one more example −
Example
class Vehicle {}
public class Car extends Vehicle {
public static void main(String args[]) {
Vehicle a = new Car();
boolean result = a instanceof Car;
System.out.println( result );
}
}
This will produce
the following result −
Output
true
Precedence
of Java Operators
Operator
precedence determines the grouping of terms in an expression. This affects how
an expression is evaluated. Certain operators have higher precedence than
others; for example, the multiplication operator has higher precedence than the
addition operator −
For example, x = 7
+ 3 * 2; here x is assigned 13, not 20 because operator * has higher precedence
than +, so it first gets multiplied with 3 * 2 and then adds into 7.
Here, operators
with the highest precedence appear at the top of the table, those with the
lowest appear at the bottom. Within an expression, higher precedence operators
will be evaluated first.
|
Category
|
Operator
|
Associativity
|
|
Postfix
|
>() [] . (dot operator)
|
Left toright
|
|
Unary
|
>++ - - ! ~
|
Right to left
|
|
Multiplicative
|
>* /
|
Left to right
|
|
Additive
|
>+ -
|
Left to right
|
|
Shift
|
>>> >>> <<
|
Left to right
|
|
Relational
|
>> >= < <=
|
Left to right
|
|
Equality
|
>== !=
|
Left to right
|
|
Bitwise AND
|
>&
|
Left to right
|
|
Bitwise XOR
|
>^
|
Left to right
|
|
Bitwise OR
|
>|
|
Left to right
|
|
Logical AND
|
>&&
|
Left to right
|
|
Logical OR
|
>||
|
Left to right
|
|
Conditional
|
?:
|
Right to left
|
|
Assignment
|
>= += -= *= /= %= >>= <<= &= ^= |=
|
Right to left
|
0 comments