# Operators in Java

There is a good operator environment provided by Java. These operators are divided into four different groups i.e. arithmetic, bitwise, relational, and logical. There are other operators also available to handle some unusual situations.

Below is a detailed description of different types of operators.

### Arithmetic operators

They are similarly used in mathematical expressions as they are used in algebra. Following are the list of arithmetic operators:

 Operator Result + Addition (also unary plus) - Subtraction (also unary minus) * Multiplication / Division % Modulus ++ Increment += Addition assignment -= Subtraction assignment *= Multiplication assignment /= Division assignment %= Modulus assignment -- Decrement

The operands of the arithmetic operators must be defined as integer type for the processing, and we can also use them on char type as the char type is a subset of int type.

The Basic Arithmetic Operators (Addition, Subtraction, Division, and Multiplication).

The basic arithmetic operators behave like the algebraic operations for numeric types. The unary minus (-) operator subtracts its single operand, and the unary plus (+) operator returns the assigned value of its operand.

The Modulus Operator (%)

This operator returns the remainder of a division operation. We can apply it on a floating-point type as well.

### Compound Assignment Operator

These operators are used to combine an arithmetic operation with an assignment. As for example:

a = a+ 10;

We can rewrite the above statement as a compound assignment operator here as:

a += 10;

In this case, the value of ‘a’ is increased by 4.

a= a% 2;

Rewritten as:

a %= 2;

In this case, the remainder of ‘a/2’ is obtained and puts back the value into the variable ‘a’.

The compound assignment operators are ‘shorthand’, so it saves us a bit of typing.

### Increment and Decrement Operator

The ++ and – are the increment and decrement operators of Java. The increment operator increases its operand by one, and the decrement operator decreases its operand by one.

x= x+1; can be written using increment operator as x++.

Similarly,

x= x-1; can be written using decrement operator as x--.

These operators appears both in postfix (a++) and prefix (++a) form. There is no difference between them, but when we use them with the large expression, then the difference between them appear such as with loops and conditional statement. In the prefix form, the operand is incremented or decremented before the value is obtained for use in the expression. In the postfix form, the value already in the operand is used in the expression, and then it is modified.

As for example:

x= 10;

y= ++x;

In this case, the value of y is set to 11 because the increment occurs before x is assigned to y.

However, when we apply the postfix increment,

X= 4;

Y= x++;

In this case, the value of y remains 4 as the value of x is obtained before the increment.

### The Bitwise Operators

The Bitwise operators work upon the individual bits of their operand. It can be used with any of the integer types. Below is a list of Bitwise operators:

 Operator Result Description ~ Bitwise unary NOT This operator reverses all the bits of the operand. It inverts all the bits of its operand. For example, 48 (00110000) becomes 207 (11001111). & Bitwise AND It returns 1 bit if both operands are also 1 and a zero is produced in all other cases. E.g. 00110000                                                           00010001 -----------------------                                                           00010000 | Bitwise OR It combines bits and returns 0 if and only if both bits are 0. And in all other cases, it returns 1. E.g. 00110000 00010001                                                                              -------------                                                                              00110001 ^ Bitwise exclusive OR It combines bits and returns 1 bit if and only if exactly one operand is 1 and in all other cases, it returns zero. E.g. 00101010 00001111 ------------- 00100101 >> Shift right Right shift operator shifts all the bits to the right at the specified number of times. It can be written in the form “value >>pos”. Here, pos denote the number of positions and value as value needed to be shifted.E.g. 00100011 >>2                                                                                  00001000 >>> Shift right zero fill This is also known as an unsigned shift right operator, which always shift zeroes into a high-order bit. E.g. 11111111 >>>3                                                                               00011111 << Shift left It shifts all the bits to the left a specified number of times. It is written in the form as “value <>4” will be written as “a >>= 4” |= Bitwise OR assignment ^= Bitwise exclusive OR assignment >>= Shift right assignment >>>= Shift right zero fill assignment <<= Shift left assignment

These operators manipulate the bit within an integer. Binary numbers of varying bit widths represent the integer types. Let’s understand using an example.

The byte value for 48 in binary is 00110000, each position represents a power of 2, starting with 20 at the rightmost bit. The next would be 21 continuing toward the left 22 or 4, then 8, 16, 32. So, 48 has 1 bits set at position 32 and 16 thus 48 is the sum of 32+16.

Table showing the outcome of each bitwise logical operation.

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

### Relational Operators

These operators determine the relationship between operands like equality and ordering.

 Operator Result Description == Equal to It returns true if operands are equal else false. != Not equal to It returns true if operands are not equals, else false. > Greater than It returns true if one operand is greater than other, otherwise false. < Less than It returns true if one operand is less than the other one, otherwise false. >= Greater than or equal to It returns true if one operand is greater than or equal to another one, otherwise false. <= Less than or equal to It returns true if one operand is less than or equal to another one, else false.

### Boolean Logical Operators

These operators operate only on Boolean operands. It combines two Boolean values to form resultant Boolean values.

 Operator Result Description & Logical AND It returns true if both operands are also true and a false is returned in all other cases | Logical OR It returns False if and only if both bits are zero, and in all other cases it returns true. ^ Logical XOR (Exclusive OR) It returns true if and only if exactly one operand is true and in all other cases it returns false. || Short-circuit OR It returns true if any one or both of its operand is true, false otherwise. && Short-circuit AND If both operands are true then only it returns true. ! Logical unary NOT It operates on a single operand and returns the reverse of the operand. True if false, false if true. == Equal to It checks if the values of two operands are equal or not, if yes it returns true. != Not equal to It checks if the left-hand side operand is not equal to right hand side. ?: Ternary if-then-else It is written in the form “expression1? expression2: expression3”. The first expression evaluates to a Boolean value, if expression1 is true then second expression is evaluated otherwise third expression.

The following table shows the effect of each logical operations:

 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