# Java Operators

Operators are used to performing operations on variables and values.

In the example below, the numbers 120 and 80 are **operands** and the `+`

sign is an **operator**:

```
int x = 120 + 80;
```

Although the `+`

operator is often used to add together two values, like in the example above, it can also be used to add together a variable and a value, or a variable and a variable:

```
int sum1 = 100 + 50; // 150 (100 + 50)
int sum2 = sum1 + 250; // 400 (150 + 250)
int sum3 = sum2 + sum2; // 800 (400 + 400)
```

In Java operators divided into the following groups:

## Arithmetic Operators

Arithmetic operators are used to performing common mathematical operations.

Operator | Name | Description | Example |
---|---|---|---|

+ | Addition | Adds together two values | x + y |

- | Subtraction | Subtracts one value from another | x - y |

* | Multiplication | Multiplies two values | x * y |

/ | Division | Divides one value from another | x / y |

% | Modulus | Returns the division remainder | x % y |

++ | Increment | Increases the value of a variable by 1 | ++x |

-- | Decrement | Decreases the value of a variable by 1 | --x |

## Assignment Operators

Assignment operators are used to assign values to variables.

In the example below, we use the **assignment** operator (`=`

) to assign the value **10** to a variable called **x**:

= | Simple assignment operator. Assigns values from right side operands to left side operand. | C = A + B will assign value of A + B into C |

+= | Add AND assignment operator. It adds right operand to the left operand and assigns the result to the left operand. | C += A is equivalent to C = C + A |

-= | Subtract AND assignment operator. It subtracts right operand from the left operand and assigns the result to the left operand. | C -= A is equivalent to C = C – A |

*= | Multiply AND assignment operator. It multiplies right operand with the left operand and assigns the result to the left operand. | C *= A is equivalent to C = C * A |

/= | Divide AND assignment operator. It divides left operand with the right operand and assigns the result to the left operand. | C /= A is equivalent to C = C / A |

%= | Modulus AND assignment operator. It takes modulus using two operands and assigns the result to the left operand. | C %= A is equivalent to C = C % A |

<<= | Left shift AND assignment operator. | C <<= 2 is same as C = C << 2 |

>>= | Right shift AND assignment operator. | C >>= 2 is same as C = C >> 2 |

&= | Bitwise AND assignment operator. | C &= 2 is same as C = C & 2 |

^= | bitwise exclusive OR and assignment operator. | C ^= 2 is same as C = C ^ 2 |

|= | bitwise inclusive OR and assignment operator. | C |= 2 is same as C = C | 2 |

## Comparison Operators

Comparison operators are used to comparing two values:

Operator | Name | Example |
---|---|---|

== | Equal to | x == y |

!= | Not equal | x != y |

> | Greater than | x > y |

< | Less than | x < y |

>= | Greater than or equal to | x >= y |

<= | Less than or equal to | x <= y |

## Logical Operators

Logical operators are used to determining the logic between variables or values:

Operator | Name | Description | Example |
---|---|---|---|

&& | Logical and | Returns true if both statements are true | x < 5 && x < 10 |

|| | Logical or | Returns true if one of the statements is true | x < 5 || x < 4 |

! | Logical not | Reverse the result, returns false if the result is true | !(x < 5 && x < 10) |

## Bitwise Operators

Java defines several bitwise operators, which can be applied to the integer types, long, int, short, char, and byte.

Operator | Description | Example |
---|---|---|

& (bitwise and) | Binary AND Operator copies a bit to the result if it exists in both operands. | (A & B) will give 12 which is 0000 1100 |

| (bitwise or) | Binary OR Operator copies a bit if it exists in either operand. | (A | B) will give 61 which is 0011 1101 |

^ (bitwise XOR) | Binary XOR Operator copies the bit if it is set in one operand but not both. | (A ^ B) will give 49 which is 0011 0001 |

~ (bitwise compliment) | Binary One's Complement Operator is unary and has the effect of 'flipping' bits. | (~A ) will give -61 which is 1100 0011 in 2's complement form due to a signed binary number. |

<< (left shift) | Binary Left Shift Operator. The left operands value is moved left by the number of bits specified by the right operand. | A << 2 will give 240 which is 1111 0000 |

>> (right shift) | Binary Right Shift Operator. The left operands value is moved right by the number of bits specified by the right operand. | A >> 2 will give 15 which is 1111 |

>>> (zero fill right shift) | Shift right, zero fill operator. The left operands value is moved right by the number of bits specified by the right operand and shifted values are filled up with zeros. | A >>>2 will give 15 which is 0000 1111 |