Operators in java

1. Java Operators
Presentation By: Shehrevar Davierwala
http://www.authorstream.com/shehrevard
http://www.slideshare.net/shehrevard
http://sites.google.com/sites/techwizardin

2. Assignment Operator (=)
lvalue = rvalue;
• Take the value of the rvalue and
store it in the lvalue.
• The rvalue is any constant,
variable or expression.
• The lvalue is named variable.
w = 10;
x = w;
z = (x - 2)/(2 + 2);

3. Mathematical Operators
Addition +
Subtraction -
Multiplication *
Division /
Modulus %

4. Simple Arithmetic
public class Example {
public static void main(String[] args) {
int j, k, p, q, r, s, t;
j = 5;
k = 2;
p = j + k;
q = j - k;
r = j * k;
s = j / k;
t = j % k;
System.out.println("p = " + p);
System.out.println("q = " + q);
System.out.println("r = " + r);
System.out.println("s = " + s);
System.out.println("t = " + t);
}
}
> java Example
p = 7
q = 3
r = 10
s = 2
t = 1
>

5. Shorthand Operators
+=, -=, *=, /=, %=
Common Shorthand
a = a + b; a += b;
a = a - b; a -= b;
a = a * b; a *= b;
a = a / b; a /= b;
a = a % b; a %= b;

6. Shorthand Operators
public class Example {
public static void main(String[] args) {
int j, p, q, r, s, t;
j = 5;
p = 1; q = 2; r = 3; s = 4; t = 5;
p += j;
q -= j;
r *= j;
s /= j;
t %= j;
System.out.println("p = " + p);
System.out.println("q = " + q);
System.out.println("r = " + r);
System.out.println("s = " + s);
System.out.println("t = " + t);
}
}
> java Example
p = 6
q = -3
r = 15
s = 0
t = 0
>

7. Shorthand Increment and Decrement +
+ and --
Common Shorthand
a = a + 1; a++; or
++a;
a = a - 1; a--; or
--a;

8. Increment and Decrement
public class Example {
public static void main(String[] args) {
int j, p, q, r, s;
j = 5;
p = ++j; // j = j + 1; p = j;
System.out.println("p = " + p);
q = j++; // q = j; j = j + 1;
System.out.println("q = " + q);
System.out.println("j = " + j);
r = --j; // j = j -1; r = j;
System.out.println("r = " + r);
s = j--; // s = j; j = j - 1;
System.out.println("s = " + s);
}
}
> java example
p = 6
q = 6
j = 7
r = 6
s = 6
>

9. Arithmetic
Operators
A Change of Topic
Casting
long
64 bit
l
int
32 bit
i

10. long
64 bit
int
32 bit
l
i
int i;
i = (int)l;
l = (long)i;
Moving Between Buckets
"Casting"
long l;
l = i;
long
64 bit
int
32 bit
l
i
Widening
Narrowing

11. The Primitive Numbers
Declaration Size and Type Number Range
byte b; // 8 bit integer -2-7
to +2+7
-1
short s; // 16 bit integer -2-15
to +2+15
-1
char c; // 16 bit Unicode 0 to +2+16
int i; // 32 bit integer -2-31
to +2+31
-1
long l; // 64 bit integer -2-63
to +2+63
-1
float f; // 32 bit floating point IEEE754 Standard
double d; // 64 bit floating point IEEE754 Standard

12. Casting the Primitives
b = (byte)s;
b = (byte)c;
b = (byte)i;
b = (byte)l;
b = (byte)f;
b = (byte)d;
i = (int)b;
i = (int)s;
i = (int)c;
i = (int)l;
i = (int)f;
i = (int)d;
l = (long)b;
l = (long)s;
l = (long)c;
l = (long)i;
l = (long)f;
l = (long)d;
s = (short)b;
s = (short)c;
s = (short)i;
s = (short)l;
s = (short)f;
s = (short)d;
2'sComplement
c = (char)b;
c = (char)s;
c = (char)i;
c = (char)l;
c = (char)f;
c = (char)d;
PositiveOnly
f = (float)b;
f = (float)s;
f = (float)c;
f = (float)i;
f = (float)l;
f = (float)d;
d = (double)b;
d = (double)s;
d = (double)c;
d = (double)i;
d = (double)l;
d = (double)f;
FloatingPoint
b = (byte)s;
b = (byte)c;
b = (byte)i;
b = (byte)l;
b = (byte)f;
b = (byte)d;
i = b;
i = s;
i = c;
i = (int)l;
i = (int)f;
i = (int)d;
l = b;
l = s;
l = c;
l = i;
l = (long)f;
l = (long)d;
s = b;
s = (short)c;
s = (short)i;
s = (short)l;
s = (short)f;
s = (short)d;
2'sComplement
c = (char)b;
c = (char)s;
c = (char)i;
c = (char)l;
c = (char)f;
c = (char)d;
PositiveOnly
f = b;
f = s;
f = c;
f = i;
f = l;
f = (float)d;
d = b;
d = s;
d = c;
d = i;
d = l;
d = f;
FloatingPoint

13. Acceptable Implicit Casts
char
16 bit
double
64 bit
float
32 bit
long
64 bit
int
32 bit
short
16 bit
byte
8 bit
Illegal
b = l;
l = f;
c = s;
OK
l = b;
i = c;
f = l

14. char
16 bit
double
64 bit
float
32 bit
long
64 bit
int
32 bit
short
16 bit
byte
8 bit
char
16 bit
double
64 bit
float
32 bit
long
64 bit
int
32 bit
short
16 bit
byte
8 bit
Automatic Promotion with Arithmetic
Illegal Casts
s = s + b;
s = s + s;
OK
s = (short)(s + b);
s = (short)(s + s);
Arithmetic is never done
in 8 or 16 bit containers.

15. char
16 bit
double
64 bit
float
32 bit
long
64 bit
int
32 bit
short
16 bit
byte
8 bit
Arithmetic Promotion with Mixed Primitives
Illegal Casts
i = i + l;
f = f + d;
l = l + f;
OK
i = (int)(i + l);
d = (double)(f + d);
l = (long)(l + f);
Arithmetic is done
in the "widest" type.

16. Implicit Casts in Method Calls
char
16 bit
double
64 bit
float
32 bit
long
64 bit
int
32 bit
short
16 bit
byte
8 bit
Illegal
i = st.indexOf(f);
OK
i = st.indexOf(c);
i = st.indexOf(b);
For: String st; and,
public int indexOf(int ch);

17. Casting
A Change of Topic
The Logical
and
Relational Operators

18. Relational Operators
> < >= <= == !=
Primitives
• Greater Than >
• Less Than <
• Greater Than or Equal >=
• Less Than or Equal <=
Primitives or Object References
• Equal (Equivalent) ==
• Not Equal !=
The Result is Always true or false

19. Relational Operator Examples
public class Example {
public static void main(String[] args) {
int p =2; int q = 2; int r = 3;
Integer i = new Integer(10);
Integer j = new Integer(10);
System.out.println("p < r " + (p < r));
System.out.println("p > r " + (p > r));
System.out.println("p == q " + (p == q));
System.out.println("p != q " + (p != q));
System.out.println("i == j " + (i == j));
System.out.println("i != j " + (i != j));
}
}
> java Example
p < r true
p > r false
p == q true
p != q false
i == j false
i != j true
>

20. Logical Operators (boolean)
&& || !
• Logical AND &&
• Logical OR ||
• Logical NOT !

21. Logical (&&) Operator Examples
public class Example {
public static void main(String[] args) {
boolean t = true;
boolean f = false;
System.out.println("f && f " + (f && f));
System.out.println("f && t " + (f && t));
System.out.println("t && f " + (t && f));
System.out.println("t && t " + (t && t));
}
}
> java Example
f && f false
f && t false
t && f false
t && t true
>

22. Logical (||) Operator Examples
public class Example {
public static void main(String[] args) {
boolean t = true;
boolean f = false;
System.out.println("f || f " + (f || f));
System.out.println("f || t " + (f || t));
System.out.println("t || f " + (t || f));
System.out.println("t || t " + (t || t));
}
}
> java Example
f || f false
f || t true
t || f true
t || t true
>

23. Logical (!) Operator Examples
public class Example {
public static void main(String[] args) {
boolean t = true;
boolean f = false;
System.out.println("!f " + !f);
System.out.println("!t " + !t);
}
}
> java Example
!f true
!t false
>

24. Logical Operator Examples
Short Circuiting with &&
public class Example {
public static void main(String[] args) {
boolean b;
int j, k;
j = 0; k = 0;
b = ( j++ == k ) && ( j == ++k );
System.out.println("b, j, k " + b + ", " + j + ", " + k);
j = 0; k = 0;
b = ( j++ != k ) && ( j == ++k );
System.out.println("b, j, k " + b + ", " + j + ", " + k);
}
}
> java Example
b, j, k true 1, 1
> java Example
b, j, k true 1, 1
b, j, k false 1, 0
>

25. Logical Operator Examples
Short Circuiting with ||
public class Example {
public static void main(String[] args) {
boolean b;
int j, k;
j = 0; k = 0;
b = ( j++ == k ) || ( j == ++k );
System.out.println("b, j, k " + b + ", " + j + ", " + k);
j = 0; k = 0;
b = ( j++ != k ) || ( j == ++k );
System.out.println("b, j, k " + b + ", " + j + ", " + k);
}
}
> java Example
b, j, k true 1, 0
> java Example
b, j, k true 1, 0
b, j, k true 1, 1
>

26. The Logical and
Relational Operators
A Change of Topic
Manipulating
the Bits 10010111

27. Logical Operators (Bit Level)
& | ^ ~
• AND &
• OR |
• XOR ^
• NOT ~

28. Twos Complement Numbers
Base 10 A byte of binary
+127 01111111
+4 00000100
+3 00000011
+2 00000010
+1 00000001
+0 00000000
-1 11111111
-2 11111110
-3 11111101
-4 11111100
-128 10000000

29. Adding Twos Complements
Base 10 Binary
+3 00000011
-2 11111110
+1 00000001
Base 10 Binary
+2 00000010
-3 11111101
-1 11111111

30. Logical Operators (Bit Level)
& | ^ ~
int a = 10; // 00001010 = 10
int b = 12; // 00001100 = 12
a 00000000000000000000000000001010 10
b 00000000000000000000000000001100 12
a & b 00000000000000000000000000001000 8
a 00000000000000000000000000001010 10
b 00000000000000000000000000001100 12
a | b 00000000000000000000000000001110 14
a 00000000000000000000000000001010 10
b 00000000000000000000000000001100 12
a ^ b 00000000000000000000000000000110 6
a 00000000000000000000000000001010 10
~a 11111111111111111111111111110101 -11
&
AND
|
OR
^
XOR
~
NOT

31. Logical (bit) Operator Examples
public class Example {
public static void main(String[] args) {
int a = 10; // 00001010 = 10
int b = 12; // 00001100 = 12
int and, or, xor, na;
and = a & b; // 00001000 = 8
or = a | b; // 00001110 = 14
xor = a ^ b; // 00000110 = 6
na = ~a; // 11110101 = -11
System.out.println("and " + and);
System.out.println("or " + or);
System.out.println("xor " + xor);
System.out.println("na " + na);
}
} > java Example
and 8
or 14
xor 6
na -11
>

32. Shift Operators (Bit Level)
<< >> >>>
• Shift Left << Fill with Zeros
• Shift Right >> Based on Sign
• Shift Right >>> Fill with Zeros

33. Shift Operators << >>
int a = 3; // ...00000011 = 3
int b = -4; // ...11111100 = -4
a 00000000000000000000000000000011 3
a << 2 00000000000000000000000000001100 12
b 11111111111111111111111111111100 -4
b << 2 11111111111111111111111111110000 -16
<<
Left
>>
Right
a 00000000000000000000000000000011 3
a >> 2 00000000000000000000000000000000 0
b 11111111111111111111111111111100 -4
b >> 2 11111111111111111111111111111111 -1

34. Shift Operator >>>
int a = 3; // ...00000011 = 3
int b = -4; // ...11111100 = -4
>>>
Right 0
a 00000000000000000000000000000011 3
a >>> 2 00000000000000000000000000000000 0
b 11111111111111111111111111111100 -4
b >>> 2 00111111111111111111111111111111 +big

35. Shift Operator Examples
public class Example {
public static void main(String[] args) {
int a = 3; // ...00000011 = 3
int b = -4; // ...11111100 = -4
System.out.println("a<<2 = " + (a<<2));
System.out.println("b<<2 = " + (b<<2));
System.out.println("a>>2 = " + (a>>2));
System.out.println("b>>2 = " + (b>>2));
System.out.println("a>>>2 = " +
(a>>>2));
System.out.println("b>>>2 = " +
(b>>>2));
}
}
> java Example
a<<2 = 12
b<<2 = -16
a>>2 = 0
b>>2 = -1
a>>>2 = 0
b>>>2 = 1073741823
>

36. Shift Operator >>> and
Automatic Arithmetic Promotion
byte a = 3; // 00000011 = 3
byte b = -4; // 11111100 = -4
byte c;
c = (byte) a >>> 2
c = (byte) b >>> 2
>>>
Right
Fill 0
a 00000011 3
a >>> 2 00000000000000000000000000000000 0
c = (byte) 00000000 0
b 11111100 -4
b >>> 2 00111111111111111111111111111111 1073741823
c = (byte) Much to big for byte 11111111 -1

37. Which Operators Operate On What
Operators
&& || !
Unary
+ - ++ --
+ - * / %
> < >= <=
== !=
<< >> >>>
& | ^ ~
=
op= etc.
floatdouble
Floating Point
char byteshortintlong
Automatic
Promotion
Except ++ - -
Automatic
Promotion
Except ++ - -
Automatic
Promotion
Except ++ - -
Automatic
Promotion
Except ++ - -
Automatic
Promotion
Except ++ - -
Automatic
Promotion
Except ++ - -
Automatic
Promotion
Automatic
Promotion
Automatic
Promotion
Integral
boolean
Logical Any
Object
+ with
String
Only
Reference
Only
Not Content

38. Assignment Operator (=) and
Classes
Date x = new Date();
Date y = new Date();
x = y;

39. Assignment Operator (=) and
Classes
Date x = new Date();
Date y = new Date();
x = y;

40. Manipulating
the Bits
A Change of Topic
Some Odds
and Ends

41. Ternary Operator
? :
If true this expression is
evaluated and becomes the
value entire expression.
Any expression that evaluates
to a boolean value.
If false this expression is
evaluated and becomes the
value entire expression.
boolean_expression ? expression_1 : expression_2

42. Ternary ( ? : ) Operator Examples
public class Example {
public static void main(String[] args) {
boolean t = true;
boolean f = false;
System.out.println("t?true:false "+(t ? true : false ));
System.out.println("t?1:2 "+(t ? 1 : 2 ));
System.out.println("f?true:false "+(f ? true : false ));
System.out.println("f?1:2 "+(f ? 1 : 2 ));
}
}
> java Example
t?true:false true
t?1:2 1
f?true:false false
f?1:2 2
>

43. String (+) Operator
String Concatenation
"Now is " + "the time."
"Now is the time."

44. String (+) Operator
Automatic Conversion to a String
If either expression_1If either expression_1 or expression_2 evaluates
to a string the other will be converted to a string
if needed. The result will be their concatenation.
expression_1 + expression_2

45. String (+) Operator
Automatic Conversion with Primitives
"The number is " + 4
"The number is " + "4"
"The number is 4"

46. String (+) Operator
Automatic Conversion with Objects
"Today is " + new Date()
"Today is " + "Wed 27 22:12;26 CST 2000"
"Today is Wed 27 22:12;26 CST 2000"
"Today is " + new Date().toString()

47. Operator Precedence
+ - ++ -- ! ~ ()
* / %
+ -
<< >> >>>
> < >= <= instanceof
== !=
& | ^
&& ||
?:
= (and += etc.)
Unary
Arithmetic
Shift
Comparison
Logical Bit
Boolean
Ternary
Assignment

48. Passing Classes to Methods
class Letter {
char c;
}
public class PassObject {
static void f(Letter y) {
y.c = 'z';
}
public static void main(String[] args) {
Letter x = new Letter();
x.c = 'a';
System.out.println("1: x.c: " + x.c); // Prints 1: x.c: a
f(x);
System.out.println("2: x.c: " + x.c); // Prints 2: x.c: z
}
}

49. Passing Primitives to Methods
class Letter {
char c;
}
public class PassPrimitive {
static void f(char y) {
y = 'z';
}
public static void main(String[] args) {
Letter x = new Letter();
x.c = 'a';
System.out.println("1: x.c: " + x.c); // Prints 1: x.c: a
f(x.c);
System.out.println("2: x.c: " + x.c); // Prints 2: x.c: a
}
}

50. End of Content