OPERATORS

• Java provides a rich operator environment.

• Most of its operators can be divided into the following
four groups.
• Arithmetic
• Bitwise
• Relational
• Logical

GRNICA 2
Arithmetic Operators….
Operator Result
+ Addition
- Subtraction (also Unary minus)
* Multiplication
/ Division
% Modulus
++ Increment
-- Decrement
+= Addition assignment
-= Subtraction assignment
*= Multiplication assignment
/= Division assignment
%= Modulus assignment
GRNICA 3
// Demonstrate several assignment operators.
class BasicMath
{
public static void main(String args[])
{
System.out.println("Integer Arithmetic");
int a = 1+1;
int b = a * 3;
int c = b / 4;
int d = c - a;
int e = -d;
System.out.println("a = " + a);
System.out.println(" b = " + b);
System.out.println("c = " + c);
System.out.println(" d = " + d);
System.out.println(" e = "+ e);
GRNICA 4
System.out.println("\n Floating Point Arithmetic");
double da = 1+1;
double db = da * 3;
double dc = (db/4);
double dd = dc - da;
double de = -dd;
System.out.println("da = " + da);
System.out.println("db = " + db);
System.out.println("dc = " + dc);
System.out.println("dd = " + dd);
System.out.println("de =" + de);
}
}

GRNICA 5
// Demonstrate the % operator.

class Modulus
{
public static void main(String args[] )
{
int x = 42;
double y = 42.25;
System.out.println(“ x mod 10 = " + x % 10) ;
System.out.println(“ y mod 10 = " + y % 10) ;
}
}

GRNICA 6
Arithmetic Assignment Operators…..
• Java provides special operators that can be used to
combine an arithmetic operation with an assignment.
Syntax Example
var = var op expn a=a%2, a=a+1, a = a >>4;
var op = expn a %=2, a+=1, a >>= 4;

GRNICA 7
// Demonstrate several assignment operators.
class OpEquals
{
public static void main(String args[])
{
int a = 1;
int b = 2;
int c = 3;
a += 5;
b *= 4;
c += a * b;
c %= 6;
System.out.println("a = " + a);
System.out.println("b = " + b);
System.out.println("c = " + c);
}
} GRNICA 8
Increment and Decrement…
• The ++ and the – – are Java’s increment and decrement
operators.
• x = x + 1; is the same as x++;
• x = x - 1; is the same as x--;
• x = 10;
y = ++x;
In the above case, y is set to 11.
• x = 10;
y = x++;
In the above case, y is set to 10.
• But in both the above cases x is still set to 11.
GRNICA 9
// Demonstrate ++.
class IncDec
{
public static void main(String args[])
{
int a = 1;
int b = 2;
int c;
int d;
c = ++b;
d = a++;
c++;
System.out.println("a = " + a);
System.out.println("b = " + b);
System.out.println("c = " + c);
System.out.println("d = " + d);
} GRNICA 10

}
The Bitwise Operators..
• Java supports several bitwise operators which can be
applied to the integer types, long, int, short, char & byte.

Operator Result
~ Bitwise unary NOT
& Bitwise AND
| Bitwise OR
^ Bitwise exclusive OR
>> Shift right
>>> Shift right zero fill
<< Shift left
GRNICA 11
…
Operator Result
&= Bitwise AND assignment
|= Bitwise OR assignment
^= Bitwise exclusive OR assignment
>>= Shift right assignment
>>>= Shift right zero fill assignment
<<= Shift left assignment

GRNICA 12
The Bitwise Logical Operators…
• The bitwise logical operators are &, |, ^ and ~.

GRNICA 13
The bitwise NOT…
• Also called bitwise complement, ~, the unary NOT
inverts all of the bits of its operand.
• 00101010 (42) becomes 11010101 after NOT applied.

The bitwise AND

• &, the AND operator produces a 1 bit if both operands
are 1 and zero in all other cases.
• 00101010 (42)
&00001111 (15)
00001010 (10)
GRNICA 14
The bitwise OR
• |, OR operator combines bits such that if either of the bits
in the operand is a 1.
00101010 (42)
| 00001111 (15)
00101111 (47)
The bitwise XOR
• The XOR operator, ^, combines bits such that if exactly
one operand is 1, then the result is 1, else result is zero.
00101010 (42)
^ 00001111 (15)
00100101 (37) GRNICA 15
// Demonstrate the bitwise logical operators.
class BitLogic
{
public static void main(String args[])
{
String binary[] = { "0000", "0001", "0010",
"0011", "0100", "0101", "0110", "0111", "1000", "1001",
"1010", "1011", "1100", "1101", "1110", "1111” };
int a = 3; // 0 + 2 + 1 or 0011 in binary
int b = 6; // 4 + 2 + 0 or 0110 in binary
int c = a | b;
int d = a & b;
int e = a ^ b;
int f = (~a & b) | (a & ~b);
int g = ~a & 0x0f;

GRNICA 16
 System.out.println(" a = " + binary[a]);
System.out.println(" b = " + binary[b]);
System.out.println(" a|b = " + binary[c]);
System.out.println(" a&b = " + binary[d]);
System.out.println(" a^b = " + binary[e]);
System.out.println("~a&b|a&~b = " + binary[f]);
System.out.println(" ~a = " + binary[g]);
}
}

GRNICA 17
The Left Shift….
• <<, left shift operator shifts all of the bits in a value to the
left a specified number of times.

Syntax : value << num;

class Byteshift
{
public static void main(String args[])
{
byte a=64,b;
int i;
i = a << 2;
b = (byte) (a << 2);
System.out.println("Original value of a: "+a);
System.out.println("i and b :"+i+" "+b);
}
} GRNICA 18
The Right Shift….
• >>, shifts all of the bits in a value to the right a specified
number of times.
Syntax: value >> num;
int a = 32;
a = a >> 2; // now a contains 8

int a = 35;
a = a >> 2; // a still contains 8, coz

00100011 >> 2 generates 00001000

(35) (8)
GRNICA 19
…..
• When we are shifting right, the top (leftmost) bits
exposed by the right shift are filled with the previous
contents of the top bit.
• This is called sign extension and serves to preserve the
sign of negative numbers which we shift them right.

11111000 (-8) in 2'complement

>>1
11111100 (-4)

GRNICA 20
The Unsigned Right Shift…..
• If we are shifting something that does not represent a
numeric value, we may not want sign extension to take
place.
• This is common when working with graphics.
• Here a zero is shifted to higher order bit no matter what
its initial value was.
• This is known as an unsigned shift.
• >>> is the operator, called as right shift with zero fill.

GRNICA 21
….
int a = -1;
a = a >>> 24;

11111111 11111111 11111111 11111111 -1 in binary as

an int
>>>24

00000000 00000000 00000000 11111111 255 in binary

as an int

• The >>> operator is often not much useful , because it is only

meaningful for 32- and 64-bit values.
GRNICA 22
Relational Operators…

Operator Result
== Equal to
!= Not equal to
> Greater than
< Less than
>= Greater than or equal to
<= Less than or equal to

GRNICA 23
The assignment Opeator….
• var=expression – assigns the value of expression to var.
• The type of Var must be compatible with the type of
expression.
• Assignment operations can be chained…

int x, y, z;
x = y = z = 100; // assign 100 to x, y, and z

GRNICA 24
The ?: Operator….
• Ternary operator that replace an if-then-else statement.
• Syntax : expression1 ? expression2 : expression3

GRNICA 25
Operator Precedence….

GRNICA 26