PDF LINK for Module 4 Download From Here 
Java Operators:
Operator: unary, binary, and ternary. It can be
applied to variables, literal or values.
Operand: variables, literal or values on which
operator is applied is known as operand.
-
Java
operators are not necessarily evaluated from left-to-right order
|
public class Welcome {
public static void main(String[]
args) {
int val1 = 10;
double val2 = 10 + 2 * --val1;
System.out.println("Value
of val1 " + val1);
System.out.println("Value
of val2 " + val2);
}
}
|
-
Order of Precedence
|
Order of operator
precedence
|
|
Post-unary operators
|
expression++, expression--
|
|
Pre-unary operators
|
++expression, --expression
|
|
Other unary operators
|
+, -, !
|
|
Multiplication/Division/Modulus
|
*, /, %
|
|
Addition/Subtraction
|
+, -
|
|
Shift operators
|
<<, >>, >>>
|
|
Relational operators
|
<, >, <=, >=, instanceof
|
|
Equal to/not equal to
|
==, !=
|
|
Logical operators
|
&, ^, |
|
|
Short-circuit logical operators
|
&&, ||
|
|
Ternary operators
|
boolean expression ? expression1 : expression2
|
|
Assignment operators
|
=, +=, -=, *=, /=, %=, &=, ^=, !=, <<=, >>=,
>>>=
|
Arithmetic Operator:
-
Addition (+),
subtraction (-),
multiplication (*),
division (/),
and modulus (%),++ and –
Calculate
the result for below expression
|
int val1 = 3 * 9 + 10
* 4 - 18;
|
Ans:
49
Evaluate
below expression
|
int val1 = 3 * (9 + 10
* 4) - 18;
|
Ans: 129
Note: operators + and += may be applied to String values, which results
in String concatenation.
Division and Modulo Operator:
|
System.out.println(100%10);
System.out.println(11%3);
System.out.println(9%10);
System.out.println(11%2);
System.out.println(100/10);
System.out.println(12%10);
System.out.println(12%3);
|
With
negative value
|
System.out.println(-100%10);
System.out.println(-11%3);
System.out.println(-9%10);
System.out.println(-11%2);
System.out.println(-100/10);
System.out.println(-12%10);
System.out.println(-12%3);
|
Numeric Promotion:
- A
long value takes
up more space than an int value.
o If
two values have different data types, Java will automatically promote one of
the values to the larger of the two data types
o If
one of the values is integral and the other is floating-point, Java will
automatically promote the integral value to the floating-point value’s data
type.
o Smaller
data types, namely byte, short, and char, are first promoted to
int any
time they’re used with a Java binary arithmetic operator, even if neither of
the operands is int.
(This rule does not apply on unary operator e.g. ++ , applying ++ to a short
value results in a short
value.)
o After
all promotion has occurred and the operands have the same data type, the
resulting value will have the same data type as its promoted operands.
|
public class Welcome {
public static void main(String[]
args) {
//Rule 1
int val1 = 10;
long val2 = 12;
System.out.println(val1+val2); //22 but
type of value will be long.
//Rule 2
double val11 = 10.1;
float val12 = 12.0f; //f is
mandatory here. or you can have (float)12.0
double result = val11+val12; //both
operands being promoted to a double
System.out.println(result); //22.1 but
type of value will be double.
//Rule 3
short v1=10;
short v2=2;
System.out.println(v1/v2); //5 but type
of value will be int. resulting output is not a short
//All rules
short x1 = 120;
float y1 = 12.0f;
double z1 = 12;
result = x1*y1/z1;
//x1 will
automatically be promoted to int
because it is a short
//The
promoted x1 value will then be automatically promoted to a float to multiply
with y1.
//The result
of x1 * y1 will then be automatically promoted to a double
System.out.println(result); //120.0
}
}
|
Unary Operator
- a
unary operator
is one that requires exactly one operand, or variable, to function.
Negation Operator
(!)
-
Also known as logical complement
operator.
|
public class Welcome {
public static void main(String[]
args) {
boolean x=false;
System.out.println(!x);
System.out.println(!!x);
int y=100;
System.out.println(-y);
}
}
|
Increment and
decrement operator:
|
public class Welcome {
public static void main(String[]
args) {
int counter = 0;
System.out.println(counter); // Outputs 0
System.out.println(++counter); // Outputs 1
System.out.println(counter); // Outputs 1
System.out.println(counter--); // Outputs 1
System.out.println(counter); // Outputs 0
int val1 = 7;
int val2 = ++val1 * 20 / val1-- + --val1;
//How this evaluated
// 8 * 20 /val1-- + --val1
// 8 * 20 /8 + --val1
//// 8 * 20 /8 + 6
// Now evaluate from left to
right
//160/8 + 6
//20+6
System.out.println("val1
is " + val1);
System.out.println("val2
is " + val2);
}
}
|
Assignment Operator:
|
public class Welcome {
public static void main(String[]
args) {
//int counter = 0.0;
int counter = (int) 0.0;
short y = (short)9999999;
short val1 = 10;
short val2 = 3;
short result = (short) (val1 * val2); // DOES NOT
COMPILE if not casted
System.out.println(counter);
System.out.println(y); //:) It is a
different value.
System.out.println(result); //:) It is a different value.
}
}
|
-
Integer
overflow: The expressions in the previous example
now compile, although there’s a cost. The second value, 9999999, is too
large to be stored as a short, so numeric overflow occurs and it becomes -27009.
Overflow is when a number is so large that it will no longer fit within the
data type, so the system “wraps around” to the next lowest value and counts up
from there. There’s also an analogous underflow, when the number is too low to
fi t in the data type.
Compounding Assignment:
|
public class Welcome {
public static void main(String[]
args) {
int v1= 10;
int v2 = 20;
v2*=v1; //Compounding
operation
System.out.println(v2);
long x = 23;
long y = (x=22);
System.out.println(x); // Outputs
22
System.out.println(y); // Also,
outputs 22
}
}
|
Relational Operator:
|
public class Welcome {
public static void main(String[]
args) {
int val1 = 10, val2 = 20, val3 = 10;
System.out.println(val1 < val2); // Outputs
true
System.out.println(val1 <= val2); // Outputs
true
System.out.println(val1 >= val3); // Outputs true
System.out.println(val1 > val3); // Outputs false
}
}
|
- a
instanceof b
: True if the reference that a points to is an instance of a class, subclass,
or class that implements a particular interface, as named in b
Logical Operators: (&), (|), and (^)
|
X & Y : AND
|
|
X | Y : Inclusive Or
|
|
X ^ Y : Exclusive Or
|
|
|
Y=true
|
y=false
|
|
|
Y=true
|
y=false
|
|
|
Y=true
|
y=false
|
|
x=true
|
TRUE
|
FALSE
|
|
x=true
|
TRUE
|
TRUE
|
|
x=true
|
FALSE
|
TRUE
|
|
X=false
|
FALSE
|
FALSE
|
|
X=false
|
TRUE
|
FALSE
|
|
X=false
|
TRUE
|
FALSE
|
Here
are some tips to help remember this table:
-
AND is only true if both operands
are true.
-
Inclusive OR is only false if both
operands are false.
-
Exclusive OR is only true if the
operands are different.
Short circuit operator: (|| and &&) :
-
The short-circuit operators are
nearly identical to the logical operators, & and |, respectively, except
that the right-hand side of the expression may never be evaluated if the final
result can be determined by the left-hand side of the expression.
|
public class Welcome {
public static void main(String[]
args) {
boolean y=false;
boolean x = true || (y=true);
System.out.println("X =
" + x + " AND Y = " + y);
boolean z = true && (y=true);
System.out.println("Z =
" + z + " AND Y = " + y);
int val1 = 6;
boolean val2 = (val1 >= 6) ||
(++val1 <= 7);
System.out.println("Val1 =
" + val1 + " AND Val2 = " + val2);
}
}
|
Equality Operators: There are
three important equality operator needs to be learned. This helps us to
determine whether two things are equal or not. Bothe require two operands and
return Boolean value.
-
equals() : It applies only for
objects.
-
== and != : This applies for both
Objects (but there is a catch) as well as primitive data types.
Let’s
take case by case scenario
1. Comparing primitive datatypes using == and !=
i. 10 == 10.0 (will return true)
ii. 10 !=5 (will return true)
|
import java.io.File;
public class Welcome {
public static void main(String[]
args) {
int v1=10;
System.out.println("Print
1 = " + (v1==10.0));
boolean x=false;
boolean y=false;
System.out.println("Print
1.A = " + (x==y));
System.out.println("Print
1.B = " + (x!=y));
String str = "HadoopExam.com";
String str1 = "QuickTechie.com";
String str2 = "HadoopExam.com";
System.out.println("Print
2 = " + str.equals(null));
System.out.println("Print
3 = " + str.equals(str1));
System.out.println("Print
4 = " + str.equals(str2));
Integer i1 = new Integer(10);
Integer i2 = new Integer(10);
System.out.println("Print
5 = " + i1.equals(i2));
System.out.println("Print
6 = " + (i1==i2)); //check here
File f1 = new File("HadoopExam.txt");
File f2 = new File("HadoopExam.txt");
File f3 = f1;
System.out.println("Print
7 = " + (f1 == f2)); // Outputs false
System.out.println("Print
8 = " + (f1 == f3)); // Outputs true
}
}
|
