Operators
Download as PPT, PDF1 like675 views
The document discusses various Java operators including assignment, arithmetic, relational, logical, bitwise, and shift operators. It provides examples of using each operator type on primitive data types like int and boolean. Key points include: - Assignment (=), arithmetic (+ - * / %), relational (>, <, ==, !=), logical (&&, ||, !) and bitwise (& | ^ ~) operators in Java. - Implicit type promotions and casts that occur with arithmetic and relational operators. - Short-circuit evaluation behavior of logical && and || operators. - Using shift operators (<< >> >>>) to manipulate bits in binary representations of integers.
![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
>](https://image.slidesharecdn.com/operators-150303085035-conversion-gate01/85/Operators-4-320.jpg)
![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
>](https://image.slidesharecdn.com/operators-150303085035-conversion-gate01/85/Operators-6-320.jpg)
![Increment and Decrement
> java example
p = 6
q = 6
j = 7
r = 6
s = 6
>
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);
}
}](https://image.slidesharecdn.com/operators-150303085035-conversion-gate01/85/Operators-8-320.jpg)
![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
>](https://image.slidesharecdn.com/operators-150303085035-conversion-gate01/85/Operators-19-320.jpg)
![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
>](https://image.slidesharecdn.com/operators-150303085035-conversion-gate01/85/Operators-21-320.jpg)
![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
>](https://image.slidesharecdn.com/operators-150303085035-conversion-gate01/85/Operators-22-320.jpg)
![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
>](https://image.slidesharecdn.com/operators-150303085035-conversion-gate01/85/Operators-23-320.jpg)
![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
>](https://image.slidesharecdn.com/operators-150303085035-conversion-gate01/85/Operators-24-320.jpg)
![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
>](https://image.slidesharecdn.com/operators-150303085035-conversion-gate01/85/Operators-25-320.jpg)
![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
>](https://image.slidesharecdn.com/operators-150303085035-conversion-gate01/85/Operators-31-320.jpg)
![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
>](https://image.slidesharecdn.com/operators-150303085035-conversion-gate01/85/Operators-35-320.jpg)
![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
>](https://image.slidesharecdn.com/operators-150303085035-conversion-gate01/85/Operators-42-320.jpg)
![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
}
}](https://image.slidesharecdn.com/operators-150303085035-conversion-gate01/85/Operators-48-320.jpg)
![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
}
}](https://image.slidesharecdn.com/operators-150303085035-conversion-gate01/85/Operators-49-320.jpg)
Ad
More Related Content
What's hot (20)
Viewers also liked (14)
Ad
Similar to Operators (20)
Ad
More from Daman Toor (10)
Recently uploaded (20)
Operators
- 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 > java example p = 6 q = 6 j = 7 r = 6 s = 6 > 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); } }
- 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. 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 The Primitive Numbers
- 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