Java Operators

Java operators are symbols that allow you to perform various operations on variables and values. These operators are classified into different categories, some of which are:

• Unary Operator,
• Arithmetic Operator,
• Shift Operator,
• Relational Operator,
• Bitwise Operator,
• Logical Operator,
• Ternary Operator and
• Assignment Operator.

Precedence of Operators in Java:

Operator Type	Category	Precedence
Unary	postfix	expr++ expr–
	prefix	++expr –expr +expr -expr ~ !
Arithmetic	multiplicative	* / %
	additive	+ –
Shift	shift	<< >> >>>
Relational	comparison	< > <= >= instance of
	equality	== !=
Bitwise	bitwise AND	&
	bitwise exclusive OR	^
	bitwise inclusive OR	|
Logical	logical AND	&&
	logical OR	||
Ternary	ternary	? :
Assignment	assignment	= += -= *= /= %= &= ^=

Java Unary Operator

Unary operators in Java work with only one operand. They are used to perform a variety of operations, including incrementing or decrementing a value by one, negating an expression, and inverting the value of a boolean. These operators are important in Java because they allow developers to modify and manipulate variables and expressions in different ways. Some common examples of Java unary operators are the increment operator (++), decrement operator (–), negative operator (-), and logical complement operator (!).

Java Unary Operator Example: ++ and —

public class OperatorExample{  
public static void main(String args[]){  
int x=20;  
System.out.println(x++);//20 (11)  
System.out.println(++x);//22  
System.out.println(x--);//22 (11)  
System.out.println(--x);//20  
}}

Output:

20
22
22
20

Java Unary Operator Example: ~ and !

public class OperatorExample{  
public static void main(String args[]){  
int a=70;  
int b=-70;  
boolean c=true;  
boolean d=false;  
System.out.println(~a);//-71 (minus of total positive value which starts from 0)  
System.out.println(~b);//69 (positive of total minus, positive starts from 0)  
System.out.println(!c);//false (opposite of boolean value)  
System.out.println(!d);//true  
}}

Output:

-71
69
false
true

Java Arithmetic Operators

Arithmetic operators in Java are fundamental mathematical operations that perform addition, subtraction, multiplication, and division. They are used to manipulate numeric values in Java programs.

Java Arithmetic Operator Example Program:

public class OperatorExample{  
public static void main(String args[]){  
int a=80;  
int b=5;  
System.out.println(a+b);//85  
System.out.println(a-b);//75  
System.out.println(a*b);//400  
System.out.println(a/b);//16  
System.out.println(a%b);//0  
}}

Output:

80
75
400
16
0

Java Arithmetic Operators Expression Program:

public class OperatorExpression{  
public static void main(String args[]){  
System.out.println(10*10/5+3-1*4/2);  
}}

Output:

21

Java Left Shift Operator

In Java, the left shift operator “<<” is used to shift all the bits of a given value towards the left side by a specified number of positions. The left shift operator is a bitwise operator, which means that it operates on each bit of the given value.

Java Left Shift Operator Program Example

public class OperatorExample{  
public static void main(String args[]){  
System.out.println(10<<2);//10*2^2=10*4=40  
System.out.println(10<<3);//10*2^3=10*8=80  
System.out.println(20<<2);//20*2^2=20*4=80  
System.out.println(15<<4);//15*2^4=15*16=240  
}}

Output:

40
80
80
240

Java Right Shift Operator

The Java right shift operator >> is an operator used to shift the bits of the left operand to the right by a specified number of times, as determined by the right operand. It is used to perform division by a power of two on signed and unsigned numbers.

Java Right Shift Operator Program Example

public OperatorExample{  
public static void main(String args[]){  
System.out.println(10>>2);//10/2^2=10/4=2  
System.out.println(20>>2);//20/2^2=20/4=5  
System.out.println(20>>3);//20/2^3=20/8=2  
}}

Output:

2
5
2

Java Shift Operator Program Example: >> vs >>>

public class OperatorExample{  
public static void main(String args[]){  
    //For positive number, >> and >>> works same  
    System.out.println(20>>2);  
    System.out.println(20>>>2);  
    //For negative number, >>> changes parity bit (MSB) to 0  
    System.out.println(-20>>2);  
    System.out.println(-20>>>2);  
}}

Output:

5
5
-5
1073741819

Java AND Operator: Logical && and Bitwise &

The behavior of the logical AND (&&) and bitwise AND (&) operators in Java is different.

The logical AND operator only evaluates the second condition if the first condition is true. This is because if the first condition is false, the overall result of the AND operation will always be false, regardless of the second condition’s value. This is known as “short-circuiting” and can be used for optimization and to avoid unnecessary computations.

On the other hand, the bitwise AND operator always checks both conditions, regardless of the first condition’s value. This is because the bitwise AND operator performs a bitwise operation on each corresponding bit of the operands, and each bit needs to be evaluated to produce the correct result.

public class OperatorExample{  
public static void main(String args[]){  
int a=10;  
int b=5;  
int c=20;  
System.out.println(a<b&&a<c);//false && true = false  
System.out.println(a<b&a<c);//false & true = false  
}}

Output:

false
false

Java AND Operator Example: Logical && vs Bitwise &

public class OperatorExample{  
public static void main(String args[]){  
int a=10;  
int b=5;  
int c=20;  
System.out.println(a<b&&a++<c);//false && true = false  
System.out.println(a);//10 because second condition is not checked  
System.out.println(a<b&a++<c);//false && true = false  
System.out.println(a);//11 because second condition is checked  
}}

Output:

false
10
false
11

Java OR Operator Example: Logical || and Bitwise |

The logical OR operator (||) in Java only checks the second condition if the first one is false. This means that if the first condition evaluates to true, the second condition is skipped. On the other hand, the bitwise OR operator (|) always checks both conditions regardless of the evaluation of the first condition. This means that both the first and the second conditions are evaluated even if the first condition is true.

public class OperatorExample{  
public static void main(String args[]){  
int a=10;  
int b=5;  
int c=20;  
System.out.println(a>b||a<c);//true || true = true  
System.out.println(a>b|a<c);//true | true = true  
//|| vs |  
System.out.println(a>b||a++<c);//true || true = true  
System.out.println(a);//10 because second condition is not checked  
System.out.println(a>b|a++<c);//true | true = true  
System.out.println(a);//11 because second condition is checked  
}}

Output:

true
true
true
10
true
11

Java Ternary Operator

The Java Ternary operator is a shorthand notation that can replace an if-then-else statement with a single line of code. It is commonly used in Java programming to simplify code and improve readability. The Ternary operator is unique in that it takes three operands, hence the name. It is used to evaluate a boolean expression and return one value if the expression is true, and another value if the expression is false.

Example:

public class OperatorExample{  
public static void main(String args[]){  
int a=2;  
int b=5;  
int min=(a<b)?a:b;  
System.out.println(min);  
}}

Output:

2

Java Assignment Operator

The Java assignment operator is a fundamental operation that is extensively used in Java programming. It is used to assign the value on the right side of the operator to the operand on its left side. This operator is denoted by the equal sign (=).

Java Assignment Operator Program

public class AssignmentOperator{  
public static void main(String args[]){  
int a=10;  
int b=20;  
a+=4;//a=a+4 (a=10+4)  
b-=4;//b=b-4 (b=20-4)  
System.out.println(a);  
System.out.println(b);  
}}

Output:

14
16

Java Assignment Operator Adding short

public class AddingShort{  
public static void main(String args[]){  
short a=10;  
short b=10;  
a=(short)(a+b);//20 which is int now converted to short  
System.out.println(a);  
}}

Output:

20

We hope you have gained a proper understanding of Java operators through this article. To continue expanding your knowledge, make sure to follow tutorials.freshersnow.com for daily updates.