**Operator** is a symbol that instructs the compiler to perform a specific action. For example, a “+” operator instructs the compiler to perform addition, a “>” operator instructs the compiler to perform comparison, “=” for assignment and so on. The operators in java are classified in eight different categories. In this guide, we will mainly discuss **Arithmetic ****operators** in Java.

In any operation, there is an operator and operands. For example: In a+b, the **“+”** symbol is the **operator** and a & b are **operands**.

## Arithmetic Operators in Java

**The five arithmetic operators in Java are**: + (addition), – (subtraction), * (multiplication), / (division), and % (modulus) represented in the following list:

### 1. + Operator Example

The addition operator, represented by symbol + is used for adding two operands. In the following example, we are adding two integer numbers using + operator.

class JavaExample { public static void main(String[] args) { //declaring integer variables int x = 100, y = 20, add; add = x+y; System.out.println("Sum of x and y is: "+add); } }

**Output:**

Sum of x and y is: 120

In the above example, both the variables x and y are integers, so the type of variable `add`

is declared int.

However if one or both variables are either float or double then the type of `add`

cannot be int. For example:

class JavaExample { public static void main(String[] args) { int x = 100; //y is float type so the variable 'add' is //declared as float type to hold the addition result float y = 20.5f, add; //addition of int and float. The result is a float add = x+y; System.out.println("Sum of x and y is: "+add); } }

**Output:**

### 2. – Operator Example

The **-(minus) arithmetic operator** returns the subtraction result of two operands. In the following example, we have two variables x and y are we are subtracting the value of y from x, the result is stored in the variable `subtraction`

.

class JavaExample { public static void main(String[] args) { int x = 100, y = 20, subtraction; //The value of y is subtracted from value of x and //the result is stored in a variable subtraction subtraction = x-y; System.out.println("The value of x - y is: "+subtraction); } }

**Output:**

The value of x - y is: 80

**Note:** The important point to note here is that while we are saying that we are subtracting the y from x, however the **values of these variables x and y remains unchanged**.

Let’s print the value of both the variables after performing an arithmetic operation to see whether is there any change.

class JavaExample { public static void main(String[] args) { int x = 100, y = 20, subtraction; subtraction = x-y; System.out.println("Subtraction result: "+subtraction); //x and y remains unchanged after any arithmetic operation System.out.println("x: "+x); System.out.println("y: "+y); } }

**Output:**

### 3. * Operator Example

class JavaExample { public static void main(String[] args) { int x = 100, y = 20, multiply; multiply = x*y; System.out.println("Multiplication of x and y is: "+multiply); } }

**Output:**

Multiplication of x and y is: 2000

In the above example, the variables x and y are integers, this is why the variable `multiply`

that holds the multiplication result is int type. However, if any of the **variable is float or double** then the variable, where the multiplication result is stored must not be integer. Let’s look at the following example:

class JavaExample { public static void main(String[] args) { int x = 100, multiply; float y = 5.5f; multiply = x*y; System.out.println("Multiplication of x and y is: "+multiply); } }

**Output:** Compilation error.

**Error can be fixed** by changing the type of `multiply`

variable. A float type variable can hold the product of int and float variables.

class JavaExample { public static void main(String[] args) { int x = 100; float y = 5.5f, multiply; multiply = x*y; System.out.println("Multiplication of x and y is: "+multiply); } }

**Output:**

Multiplication of x and y is: 550.0

### 4. / Operator Example

The / operator returns the quotient after dividing an operand by another operand. For example, ‘/’ operator would return 2, if 100 is divided by 50 (100/50 == 2), however the **% modulus operator** would return 0 for the same operation as it returns **remainder**.

class JavaExample { public static void main(String[] args) { int x = 100, y = 20, division; //The '/' arithmetic operator divides the variable x by //variable y and returns the quotient division = x/y; System.out.println("Quotient value after dividing x by y: "+division); } }

**Output:**

Quotient value after dividing x by y: 5

Similar to the multiplication example, if any of the variable is of float or double type then the variable, where the result is stored must have the float or double data type.

class JavaExample { public static void main(String[] args) { int x = 100; float y = .25f, division; //In this arithmetic operation, one of the variable is of float //type so the 'division' variable is declared 'float' type. division = x/y; System.out.println("Quotient value after dividing x by y: "+division); } }

**Output:**

Quotient value after dividing x by y: 400.0

### 5. % Operator Example

class JavaExample { public static void main(String[] args) { int x = 100, y = 20, mod; //The modulus operator '%' returns the remainder after division //In this case, the value 100 is perfectly divisible by value 20 //thus the modulus is 0 here as no remainder. mod = x % y; System.out.println("Remainder value after dividing x by y: "+mod); } }

**Output:**