## Key Points

- Operators in Java are symbols that allow you to operate on one or more values, known as operands.
- There are several different types of operators, including arithmetic, comparison, logical, and bitwise.
- Arithmetic operators in Java allow you to perform mathematical operations on numeric data types.
- Comparison operators in Java compare two values and return a boolean (true or false) depending on the result.

Operators in Java make up a crucial part of this programming language’s foundation. You wouldn’t get far without being able to perform simple operations. And that’s why operators are a fundamental and important part of Java, allowing for the most common operations in programming.

Performing calculations, determining true or false, figuring out relations – you need operators to do anything. And that doesn’t go for just Java, but every other language out there.

In this blog post, we will go over the most used operators in Java, as well as some examples so you can see how they work. Let’s get to it!

## What are Operators in Java?

Operators are frequently used in programming. At a basic level, operators are symbols that allow you to operate on one or more values, known as operands. Whether it’s the assignment operator (=) or the ternary operator (?), programs are often littered with them. We will now go over the most common types of operators.

## Arithmetic Operators

As the name suggests, arithmetic operators allow you to perform mathematical operations. They will work on any numeric data type.

### Addition (+)

The addition operator allows you to add two numbers together. Here, **sum** will be the sum of 3 and 5:

int sum = 3 + 5; // sum will be 8 |

It can also be used to concatenate (or add) two strings together. Here, **result** becomes the concatenation of “Hello “ and “World!”

String result = “Hello ” + “World!”; // result will be “Hello World!” |

### Subtraction (-)

The subtraction operator allows you to subtract one number from another. Here, **difference** will be the difference of 5 and 3:

int difference = 5 – 3; // difference will be 2 |

### Multiplication (*)

The multiplication operator allows you to multiply two numbers. Here, **product** will be the product of 5 and 3:

int product = 5 * 3; // product will be 15 |

### Division (/)

The division operator allows you to divide two numbers. If both operands are integers, then it will be *floored* division, meaning the quotient is floored. To avoid this, at least one operand must be a floating-point number. Here, **quotient** will be the floored quotient of 5 and 3:

int quotient = 5 / 3; // quotient will be 1 |

### Modulo (%)

The modulo operator allows you to take one number *modulo* another number. In other words, it gives you the remainder after dividing one integer by another. Here, **remainder** will be the remainder of 10 modulo 3:

int remainder = 10 % 3; // remainder will be 1 |

### Increment (++)

The increment operator increments a variable by 1. If the operator is before the variable, the variable will be incremented by 1, and the value after incrementing will be returned. However, if it is after the variable, the value before incrementing will be returned.

int a = 5;a++; // a will be 6 |

### Decrement (–)

The decrement operator decrements a variable by 1. If the operator is before the variable, the variable will be decremented by 1, and the value after decrementing will be returned. However, if it is after the variable, the value before decrementing will be returned.

int a = 5;a–; // a will be 4 |

## Assignment Operators

### Assignment Operator (=)

The assignment operator is quite simple: it allows you to assign a value to a variable. For example, if you write:

int a = 5; |

Then **a** will be 5.

### Compound Assignment Operators

The assignment operator can be combined with other arithmetic and bitwise operators (these will be covered later.) This means that instead of having to write:

[variable] = [variable] [operator] [operand] |

You can write:

[variable] [compound assignment operator] [operand] |

Confused? These examples should help. This includes all compound assignment operators:

int x = 10;x += 5; // Equivalent to x = x + 5; (x will be 15) int y = 8;y -= 3; // Equivalent to y = y – 3; (y will be 5) int z = 6;z *= 2; // Equivalent to z = z * 2; (z will be 12) int a = 16;a /= 4; // Equivalent to a = a / 4; (a will be 4) int b = 11;b %= 3; // Equivalent to b = b % 3; (b will be 2) int c = 9;c &= 3; // Equivalent to c = c & 3; (c will be 1) int d = 7;d |= 5; // Equivalent to d = d | 5; (d will be 7) int e = 10;e ^= 3; // Equivalent to e = e ^ 3; (e will be 9) int f = 16;f <<= 2; // Equivalent to f = f << 2; (f will be 64) int g = 32;g >>= 3; // Equivalent to g = g >> 3; (g will be 4) int h = -16;h >>>= 2; // Equivalent to h = h >>> 2; (h will be 1073741819) |

## Comparison Operators

Comparison operators compare two operators and return a boolean (true or false) depending on the result.

### Equal To (==)

The equal to operator checks if two values are equal to each other.

int a = 5;int b = 3;boolean result = (a == b); // result will be false |

### Not Equal To (!=)

The not equal to operator checks if two values are not equal to each other.

int a = 5;int b = 3;boolean result = (a != b); // result will be true |

### Greater Than (>)

The greater than operator checks if the left operand is greater than the right operand.

int a = 5;int b = 3;boolean result = (a > b); // result will be true |

### Less Than (<)

The less than operator checks if the left operand is less than the right operand.

int a = 5;int b = 3;boolean result = (a < b); // result will be false |

### Greater Than or Equal To (>=)

The greater than or equal to operator checks if the two operands are equal or if the left operand is greater than the right operand.

int a = 5;int b = 3;boolean result = (a < b); // result will be false |

### Less Than or Equal To (<=)

The less than or equal to operator checks if the two operands are equal or if the left operand is less than the right operand.

int a = 5;int b = 3;boolean result = (a <= b); // result will be false |

## Logical Operators

Logical operators operate on booleans and return a boolean depending on the relationship between the operands. Note that the operands do not have to be literal booleans (**true **or **false**). They can also be and usually are their own expressions that evaluate to a boolean.

### Logical AND (&&)

The logical AND operator checks if the two operands are both true.

boolean a = true;boolean b = false;boolean result = (a && b); // result will be false |

### Logical OR (||)

The logical OR operator checks if either or both of the operands are true.

boolean a = true;boolean b = false;boolean result = (a || b); // result will be true |

### Logical NOT (!)

The logical NOT operator reverses the truth value of the operand.

boolean a = true;boolean result = !a; // result will be false |

## Bitwise Operators

A bitwise operator is one that operates on values at a *bit level.* They will return different numbers depending on the operands.

### Bitwise AND (&)

The bitwise AND operator will return a number that has 1’s where both operands have 1’s in their bits and 0’s otherwise.

int a = 5; // Binary: 00000101int b = 3; // Binary: 00000011int result = a & b; // Binary: 00000001 (result will be 1) |

### Bitwise OR (|)

The bitwise OR operator will return a number that has 1’s where either or both operands have 1’s in their bits and 0’s otherwise.

int a = 5; // Binary: 00000101int b = 3; // Binary: 00000011int result = a | b; // Binary: 00000111 (result will be 7) |

### Bitwise XOR (^)

The bitwise XOR operator will return a number that has 1’s where either but not both of the operands have 1’s in their bits and 0’s otherwise.

int a = 5; // Binary: 00000101int b = 3; // Binary: 00000011int result = a ^ b; // Binary: 00000110 (result will be 6) |

### Bitwise NOT (~)

The bitwise NOT operator will return a number with 1’s where the operand has 0’s in its bits and 0’s where the operand has 1’s.

int a = 5; // Binary: 00000101int result = ~a; // Binary: 11111010 (result will be -6) |

### Left Shift (<<)

The left shift operator will return a number that has all the bits of the left operand shifted to the left by the number of times specified by the right operand.

int a = 5; // Binary: 00000101int result = a << 2; // Binary: 00010100 (result will be 20) |

### Right Shift (>>)

The right shift operator will return a number that has all the bits of the left operand shifted to the right by the number of times specified by the right operand. The new bit positions on the left will be filled in with the original sign bit (the first bit).

int a = 16; // Binary: 00010000int result = a >> 2; // Binary: 00000100 (result will be 4) |

### Unsigned Right Shift (>>>)

The unsigned right shift operator will return a number that has all the bits of the left operand shifted to the right by the number of times specified by the right operand, but all bits on the left will be filled in with 0’s, regardless of the sign of the number.

int a = -16; // Binary: 11110000int result = a >>> 2; // Binary: 00111100 (result will be 60) |

## Ternary Operator (?)

The ternary operator got its name from the number of operands it works on: three.

The logical NOT operator is a unary operator, because it works on one operand. The addition operator is a binary operator because it works on two operands. Thus, the operator that works on three operands is ternary. Makes sense, right?

The ternary operator is a concise way of writing conditional expressions in Java. It takes the general form:

[condition] ? [true_expression] : [false_expression] |

Essentially, if the condition is true, then the ternary operator will return the true expression, and if the condition is false, it will return the false expression. For example, here’s how you could determine the max number using it:

int a = 5;int b = 3;int max = (a > b) ? a : b; // max will be equal to a |

## Operators in Java: Wrapping Up

Operators are an essential part of Java, and they are going to be used in any type of task you accomplish through programming. By knowing all of them, you will be best equipped to deal with problems, as you may know, the *simplest* way.

There is no way to avoid operators in Java if you are trying to master this language. So, we encourage you to learn more about operators and make the most of them while programming!

The image featured at the top of this post is ©ChristianChan/Shutterstock.com.