Agenda:
- Increment and Decrement operators
- Arithmetic operators
- String concatenation operator
- Relational operators
- Equality operator
- "instanceof" operator
- Bitwise operator
- Short circuit operators
- Typecast operator
- Assignment operator
- Ternary operator
- New operator
- [] operator
Increment & Decrement
operators:
Pre increment E.g.:
y = ++x;
Pre decrement E.g.:
y = --x;
Postincrement E.g.
: y = x++;
Postdecrement E.g.:
y = x--;
- In Preincrement or Predecrement first value gets
increased or decreased then the assignment will happen(value is used).
- But in Postincrement or Postdecrement first
assignment(value is used) will happen then value gets increased or
decreased.
For example:
1.
class Test{
2.
public static void
main(String[] args){
3.
int x=10;
4.
int y=20;
5.
System.out.println(x++);
6.
System.out.println(++y);
7.
int a = 10;
8.
a = a++ +a + a-- -a-- +
++a;
9.
System.out.println(a);//(10
+ 11 + 11 -10 + 10 = 32)
10.
}
11.
}
Output:
10
21
32
Note:
- The evaluation of expression starts from Left
to Right.
- The value assignment starts from Right to Left.
- Increment or decrement operators only valid for variables not for constant values.
- E.g.: 10++ // invalid
- Nesting of increment or decrement operators is not permitted.
- E.g.: int x=10;
int y =++(++x)//Compiler Error(It will become constant)
- Increment or decrement operator for final
variables are not permitted.
- E.g.: final int x =10;
int y = ++x;//compiler Error.
- Increment or decrement operator is not allowed on boolean
variables.
Arithmetic
Operators(+,-,*,/,%):
If you apply any
arithmetic operator between two variables a and b, the result type is always
max(int,type of a, type
of b);
E.g.:
- byte+byte = int
- byte+short =int
- byte+int = int
- char + char = int
- int + long = long
- float +double = double
- System.out.println('a'+1);//98
Infinity:
- For Integral arithmetic(byte,short,int,long) there is
no way to represent infinity or undefined results.
- Hence, If infinity or undefined is the result then we
will get ArithmeticException.
- System.out.println(10/0);//AE
- System.out.println(0/0);//AE
- But for floating-point arithmetic(float, double) there
is a way to represent infinity or undefined results.
- For this Float and Double classes contains the
following constants.
- POSITIVE-INFINITY
- NEGATIVE-INFINITY
- NaN(Not a number)
- Hence, If infinity or undefined results are the results
we won't get any runtime exception.
E.g.:
1.
System.out.print(10/0.0);//+infinity
2.
System.out.println(10.0/0);//+infinity
3.
System.out.println(-10/0.0);//-infinity
4.
System.out.println(-10.0/0);//-infinity
5.
System.out.println(0/0.0);//NaN
6.
System.out.println(0.0/0);//NaN
7.
System.out.println(-0.0/0);//NaN
8.
System.out.println(-0/0.0);//NaN
Note:
- ArithmeticException(AE) is a RuntimeException not
compile-time exception.
- AE is only for integral arithmetic not for floating-point
arithmetic.
- Only operators(/,%) causes AE.
String concatenation
operator:
- "+" is the only overloaded operator in java.
- Sometimes "+" operator acts as arithmetic addition and sometimes it acts as concatenation.
- If at least one argument is string type then
"+" operator acts as concatenation.
- If all arguments are number type then the "+" the operator acts as an additional operator.
For E.g.:
- String a ="anu";
- int b=10,c=20;
- System.out.println(a+b+c);//anu1020
- System.out.println(b+c+a);//30anu
Relational operators(>, <, >=, <=):
- You can apply relational operators for every primitive type except boolean.
- You can't apply relational operators for the object type.
- You can't perform nesting of relational operators.
- Ex: System.out.println(10<20<30);//Compiler
Error.
Equality Operators(==,
!=):
- You can apply equality operators for every primitive
type including boolean type also
- You can also apply equality operators for an object
reference.
- Means, if you compare two objects reference r1,r2 using
==(double equal operator),
- then r1==r2 return true if and only if both r1 and r2
pointing to the same object.
- To use equality operator compulsory there should be
some relationship between argument type(either parent-child or
child-parent or same type),
- otherwise, you will get a compiler error(incomparable
types).
= = vs .equals():
- = = operator compare address/location whereas .equals()
compare content.
- For E.g.:
- String s1 = new String("anu");
- String s2 = new String("anu");
- System.out.println(s1==s2);//false
- System.out.println(s1.equals(s2));//true
Instanceof operator:
- You can use this operator to check whether the given
object is of particular type or not.
- syntax: <object reference> instanceof <class
or interface name>
- To use this operator compulsory there should be some
relationship between argument type(either parent-child or child-parent or the same type), otherwise you will get a compiler error(incomparable types).
- Whenever you are comparing parent object is child type
or not by using instanceof operator then you will get
false as output.
- For any class or interface X, null instanceof X
the result is always false.
Bitwise operators:
- &(AND): If
both the arguments are true then the result is true.
- |(OR): If
at least one argument is true, then the result is true.
- ^(X-OR): If both are different arguments, the result is true.
- System.out.println(true & false);//false
- System.out.println(true | false);//true
- System.out.println(true ^ false);//true
Note:
&, |, ^ : Applicable for both boolean and integral types.
Bitwise complement(~ tild
operator):
- It works with only Integral types.
- It inverts all bits of its operand, means it
convert 0 ---> 1 and 1---> 0
Trick
- If value is +ve integer, then increase value by 1 and
put negative prefix.
- int a =10;
- System.out.println(~a);// -11
- If value is -ve integer, then decrease value by 1 and
put positive prefix.
- int a =-9;
- System.out.println(~a);// 8
Boolean
complement(!) operator:
This operator is
applicable only for boolean types not for integral types.
System.out.println(!false);//
true
Short circuit(&&,
||) operators vs Bitwise operators(&, |)
- In bit-wise operators both the argument should be
evaluated while in short circuit operators the second argument is
optional.
- For example:
- r1&&r2, r2 will be evaluated if and only if r1
is true.
- r1||r2, r2 will be evaluated if and only if r1 is
false.
- In bit-wise operator is applicable for both integral
and boolean types while short circuit operator is applicable only for
boolean types.
Typecast
operator(primitive type-casting)
1.
Implicit typecasting.
2.
Explicit typecasting.
Implicit type casting:
- The compiler is responsible for this typecasting.
- Whenever you are assigning smaller data type value to the bigger data type variable this typecasting will be performed. Also known as widening or up-casting.
- There is no loss of information in this typecasting.
- The following are various possible implicit typecasting.
Explicit type casting
- A programmer is responsible for this typecasting.
- Whenever you are assigning bigger data type value to
the smaller data type variable then explicit typecasting is required.
- Also known as Narrowing or downcasting.
- There may be a chance of loss of information in this
typecasting.
- Whenever you are assigning bigger data type value to
the smaller data type variable by explicit typecasting the most
significant bit(MSB) will be lost.
- Whenever you are assigning floating-point data types to
the integer data type by explicit typecasting the digits after the decimal the point will be lost.
- E.g.:
- float x =150.45f;
- int i = (int)x;
- System.out.println(i);//150
Assignment Operator:
Simple assignment operator:
E.g.: int x =10;
Chained assignment
operator
int a,b,c,d;
a=b=c=d=20;
You can't perform
chained assignment at the time of declaration.
E.g.: int a=b=c=d=20;
Compound assignment
operator
- += E.g.: int a+=1; is equivalent to int a=a+1;
- -= E.g.: int a-=1; is equivalent to int a=a-1;
- *= E.g.: int a*=1; is equivalent to int a=a*1;
- /= E.g.: int a/=1; is equivalent to int a=a/1;
- %= E.g.: int a%=1; is equivalent to int a=a%1;
- &=
- !=
- ^=
- >>=
- >>>=
- <<=
Conditional Operators:
- Ternary operator(?:) is the only conditional operator
in java.
- int x = 10>20?30:40;
- System.out.println(x);//40
- You can perform nesting of Ternary operator.
- int x =10>20?30:(50>10)?40:60;
- System.out.println(x);//40
New operator:
- You can use new operator to create an
object.
- In java, there is no delete operator for the destruction of the objects.
- The garbage collector is responsible for destroying the objects.
[] operator:
- You can use [] operator to declare and construct arrays.
Shift operators:
Right shift
operators(>>):
- It shifts binary bits to right.
- e.g int a=4;int b=a>>2;
- Here binary bits shift 2 position right and at empty
place fill 0 if the number is +ve and if the number is
-ve fill 1.
- Assume the size of the int is 1 byte. So,4 will store
in memory like 00000100 after shifting one position right and at empty place fill 0 (because the number is positive) It will become 00000010. Again shifting
one position right it will become 00000001 and it's
decimal value is 1 System.out.println(b);//1
Left shift
operators(<<):
- It shifts binary bits to left.
- e.g int a=4; int b=a<<2;
- Here binary bits shift 2 positions left and at empty
place fill 0 either number is negative or positive.
- Assume the size of the int is 1 byte. So,4 will store
in memory like 00000100 after shifting one position left and at empty place fill 0. It will become 00001000
- Again shifting one position left it will become 00010000 and
its decimal value is 16
- System.out.println(b);//16
Shift Right Zero Fill
operator(>>>):
- It shifts binary bits to right and put 0 at the
empty place(No matter number is +ve or -ve)
- Its result will be always a positive number.
- e.g byte a = -4;
- int b
=a>>>2;//111111111111111111111111111111(30 times 1)
- System.out.println(b);//1073741823
Note: For shift, operator apply max(int, type of a, type of b);
E.g.:
byte a=4;
int b=a>>2;
int c=a<<2;
int d=a>>>2;
Java operator precedence:
1.Unary operators:
[],x++,x--
++x,--x,~,!
new
2.Arithmetic operators:
*,/,%
+,-
3.Shift operators:
>>,>>>,<<
4.Comparision operators:
<,<=,>,>=,instanceof
5.Equality operators:
==,!=
6.Bitwise operators:
&,^,|
7.Short circuit
operators:
&&,||
8.Conditional operators:
?:
9.Assignment operators:
+=,-=,*=,/+,%=
