An operator is a symbol that tells the compiler to perform a specific mathematical, logical or other manipulation. Java has four general classes of operators.

Arithmetic Operators:  The operators that are used to carry out fundamental arithmetic operations are called arithmetic operators. The following table shows complete set of arithmetic operators.

 S.N Operator Meaning 1 + Addition 2 – Subtraction 3 * Multiplication 4 / Division 5 % Modulus 6 ++ Increment 7 — Decrement 8 += Addition Assignment 9 -= Subtraction Assignment 10 *= Multiplication Assignment 11 /= Division Assignment 12 %= Modulus Assignment

The operands of the arithmetic operators must be of a numeric type. We cannot use them on boolean types, but we can use them on char types since the char in Java is subset of int.

The following program illustrates the use of arithmetic operators.

```public class BasicMath{

public static void main(String[] args) {

int a = 2;

int b = a*3;

int c = b/2;

int d = c-a;

int e = -d;

System.out.println("Arithmetic using integers");

System.out.println("a = "+a);

System.out.println("b = "+b);

System.out.println("c = "+c);

System.out.println("d = "+d);

System.out.println("e = "+e);

System.out.println("Arithmetic using doubles");

double da = 2.00;

double db = da*3;

double dc = db/4;

double dd = dc-a;

double de = -dd;

System.out.println("da = "+da);

System.out.println("db = "+db);

System.out.println("dc = "+dc);

System.out.println("dd = "+dd);

System.out.println("de = "+de);

}

}```

The output of the above program is:

Arithmetic using integers

a = 2

b = 6

c = 3

d = 1

e = -1

Arithmetic using doubles

da = 2.0

db = 6.0

dc = 1.5

dd = -0.5

de = 0.5

The Modulus Operator: The modulus operator, %, returns the remainder of a division operation. It can be applied to floating point as well as integer types. The following example program demonstrates the %;

Let us consider the following program

```public class Modulus{

public static void main(String[] args) {

int x = 42;

double y = 42.25;

System.out.println("x mod 10 ="+x%10);

System.out.println("y mod 10 = "+y%10);

}

}```

The output of the above program is:

x mod 10 =2

y mod 10 = 2.25

Increment and Decrement Operator

The increment operator increases its operand by one. The decrement operator decreases its operand by one. For example, the statement:

x = x+1;

can be rewritten like this by use of the increment operator:

x++;

Similarly , this statement

x = x-1;

is equivalent to

x–;

Let us consider the following program:

```
public class IncDec{

public static void main(String[] args) {

int a = 1;

int b = 2;

int c;

int d;

c = ++b;

d = a++;

c++;

System.out.println("a = "+a);

System.out.println("b = "+b);

System.out.println("c = "+c);

System.out.println("d = "+d);

}

}```

The output of the above program is:

a = 2

b = 3

c = 4

d = 1

The Bitwise Operator

Java provides several bitwise operators which can be applied to the integer types, long, int, short, char and byte. These operators act upon the individual bits of their operands.

The Bitwise Logical Operators

The bitwise logical operators are &, |, ^ and ~. The following table shows the output of each operation. The bitwise operators are applied to each individual bit within each

 A B A|B A&B A^B ~A 0 0 0 0 0 1 1 0 0 0 1 0 0 1 0 0 1 1 1 1 1 1 0 1

The Bitwise NOT: This is also called bitwise complement. It is a unary operator. It is denoted by the sign ‘~’. It inverts all of the bits if its operand. For example, the number 42 has the following bit pattern:

00101010

becomes 11010101 after the NOT operator is applied.

The Bitwise AND

The AND operator, &, produces a 1 bit if both operands are also 1. A zero is produced in all other cases. Here is an example:

00101010         42

&00001111         15

00001010         10

The Bitwise OR

The OR operator,|, combines bits such that if either of the bits in the operands is a 1, then the resultant bit is a 1. Let us take the above example:

00101010            42

|00001111          15

00101111         47

The Bitwise XOR

The XOR operator, ^, combines the bits such that if exactly one operand is 1, then the result is 1. Otherwise, the result is zero. Let us consider the following program:

00101010          42

^00001111          15

00001111          10

The following program illustrates the bitwise operators.

```public class BitLogic {

public static void main(String[] args) {

String binary[] = {"0000","0001","0010","0011","0100","0101","0110","0111",

"1000","1001","1010","1011","1100","1101","1110","1111"};

int a=3;

int b = 6;

int c = a|b;

int d = a&b;

int e = a^b;

int f = (~a&b)|(a&~b);

int g = ~a&0x0f;

System.out.println ("a = "+binary[a]);

System.out.println ("b = "+binary[b]);

System.out.println ("c = "+binary[c]);

System.out.println ("d = "+binary[d]);

System.out.println ("e = "+binary[e]);

System.out.println ("(~a&b)|(a&~b) = "+binary[f]);

System.out.println("~a&0x0f = "+binary[g]);

}

}```

The output of the above program is:

a = 0011

b = 0110

c = 0111

d = 0010

e = 0101

(~a&b)|(a&~b) = 0101

~a&0x0f = 1100

The Left Shift

The left shift operator, <<, shifts all of the bits in a value to the left a specified number of times. It has the general form:

value<<num

Here, num specifies the number of positions to left-shift the value in value. That is , the<< moves all of the bits in the specified value to the left by the number of bit positions specified by num. For each, shift, the higher order bit is shifted out (and lost), and zero is brought in on the right. This means that when a left shift is applied to an int operand, bits are lost once they are shifted past bit position 31. If the operand is a long, then bits are lost after bit position 63.

Let us consider the following program

```public class ByteShift {

public static void main (String[] args){

byte a = 64,b;

int i;

i = a<<2;

b = (byte)(a<<2);

System.out.println ("Original value of a:"+a);

System.out.println ("i and b "+i+" "+b);

}

}```

The output of the above program is:

Original value of a : 64

i and b 256 0

Since a is promoted to int for the purpose of evaluation, left shifting the value 64 (0100 0000) twice results in i containing the value 256 (1 0000 0000). However, the value in b contains 0 because after the shift, the low, order byte is now zero. Its only 1 bit has been shifted out

Let us see one program.

```public class ByteShift {

public static void main(String[] args){

int i;

int num = 0xFFFFFFE;

for (i=0;i<6;i++)

{

num = num<<1;

System.out.println (num);

}

}

}```

The output of the above program is:

536870908

1073741816

2147483632

-32

Since each bit shift has the effect of doubling the original value, programmers frequently use this fact as an efficient alternative to multiplying by 2. We must be careful while shifting bits. If we shift a 1 bit into the high-order position (bit 31 or 63), the value will become negative.

The Right Shift

The right shift operator, >>, shifts all of the bits in a value to the right a specified number of times. Its general form is shown as below:

value>>nums

Here, num specifies the number of positions to right shift the value in value. That is, the >> moves all of the bits in the specified value to the right the number of bits positions specified by num.

The following code fragment shifts the value 32 to the right by two positions, resulting a being set to 8.

int a = 32;

a = a>>2; // a is now 8

When a value has bits that are “shifted off”, those bits are lost.

Let us look on one more example:

00100011            35

>>2

00001000            8

Each time we shift a value to the right; it divides that value by two and discards any remainder. We can take advantage of this for high performance integer division by 2 but we must sure that we are not shifting any bits off the right end

Relational Operators

The relational operators determine the relationship that one operand has to the other. Specifically, they determine equality and ordering. The relational operators are as follows:

 S.N Operator Meaning 1 == Equal to 2 != Not equal to 3 > Greater than 4 < Less than 5 >= Greater than or equal 6 <= Less than or equal to

The outcome of these operations is a boolean value. He relational operators are most frequently used in the expressions that control the if statement and various loop statements. The relational operator can be illustrated using following program.

```public class RelatioalOpDemo {

public static void main(String[] args) {

int a =4;

int b = 1;

boolean c = a<b;

System.out.println("a = "+a);

System.out.println("b = "+b);

System.out.println("c = "+c);

System.out.println("a>b is "+(a>b));

}

}```

The output of the above program is:

a = 4

b = 1

c = false

a>b is true

Boolean Logical Operators

The Boolean logical operators operate only on boolean operands. That is, the boolean logical operators are used to combine two or more relational operator to produce single boolean value.

The following table shows logical operators and their meaning

 S.N Operator Name 1 & Logical AND 2 | Logical OR 3 ^ Logical XOR(Exclusive OR) 4 || Short circuit OR 5 && Short Circuit AND 6 ! Logical unary NOT 7 &= AND assignment 8 |= OR assignment 9 ^= XOR assignment 10 == Equal to 11 != Not Equal to 12 ?: Ternary if then –else

The logical Boolean operators, &,|, and ^, operate on boolean values in the same way that they operate on bits of an integer. The logical! operator inverts the Boolean state. !true =false and! false = true. The following table shows the effect of each logical operation.

 A B A|B A&B A^B !A False False False False False True True False True False True False False True True False True True True True True True False False

Let us consider the following program

```public class BoolLogic {

public static void main(String[] args) {

boolean a = true;

boolean b = false;

boolean c = a|b;

boolean d = a&b;

boolean e = a^b;

boolean f = (!a&b)|(a&!b);

boolean g = !a;

System.out.println("a = "+a);

System.out.println("b = "+b);

System.out.println("a|b = "+c);

System.out.println("a&b = "+d);

System.out.println("a^b = "+e);

System.out.println("(!a&b)|(a&!b) = "+f);

System.out.println("!a = "+g);

}

}```

The output of the above program is

a = true

b = false

a|b = true

a&b = false

a^b = true

(!a&b)|(a&!b) = true

!a = false

Short –Circuit Logical Operators

Java provides two interesting Boolean operators not found in many other computer languages. These are secondary versions of the Boolean AND and OR operators and are known as short-circuit operators. The OR operator results in true when A is true, no matter what B is. Similarly, the AND operator results in false when A is false, no matter what B is. If we use the || and && forms, rather than the | and & forms of these operators, Java will not bother to evaluate the right hand operand when the outcome of the expression can be determined by the left operand alone. This is very useful when the right hand operand depends on the left one being true or false in order to function properly.

Let us consider the following code segment

if(denom!=0&&num/denom>10)

{

….

}

When short-circuit form of AND (&&) is used, there is no risk of causing a run time exception when denom is zero.

The Assignment Operator

The assignment operator is the single equal sign,=. The assignment operator works in Java much as it does in any other computer language. It has this general form:

var = expression;

Here, the type of the var must be compatible with the type of expression.

The assignment operator does have one interesting attribute that we may not be familiar with; it allows us to create a chain of assignments. For example, consider this fragment:

int x, y, z;

x = y = z = 100;

This fragment sets the variables x, y and z to 100 using a single statement. This work because the = is an operator that yields the value of the right hand expression. Thus, the value of the right hand expression. Thus, the value z = 100, which is then assigned to y, which in turn is assigned to x. Using a “ chain of assignment” is an easy way to set a set of a group of variables to a common value.

The?: Operator

Java includes a special ternary (three way) operator that can replace certain types of if-then- else statements. The?: has following form.

expression1? expression2:expression3

Here, exppression1 can be any expression that evaluates to a boolean value. If expression1 is true, then expression2 is evaluated, otherwise, expression3 is evaluated.

Let us consider the following program:

```public class Ternary {

public static void main(String[] args) {

int i, k;

i=10;

k = i<0?-i:i;

System.out.println ("Absolute value of i = "+k);

i=-10;

k = i<0?-i: i;

System.out.println ("Absolute value of i = "+k);

}

}```

The output of the above program is:

Absolute value of i = 10

Absolute value of i = 10

Operator Precedence: The precedence of a Java operator is given as follows:

 Highest () [] ++ — * / ~ ! + – >> >>> << > >= < <= == != & ^ | && || ?: = op= Lowest

Using Parentheses

Parentheses raise the precedence of the operations that are inside them. This is often necessary to obtain the result we desire. For example, consider the following expression:

a>>b+3

This expression first adds 3 to b and then shifts a right by that result. That is, this expression can be rewritten using redundant parenthesis like this:

a>>(b+3)

However, if we want to first shift a right by b positions and then add 3 to that result, we will need to parenthesize the expression like this:

(b>>b)+3