# Java Arithmetic Operators Tutorial

In this section, we will learn what arithmetic operators are and how they work in Java.

## What is Arithmetic Operator in Java?

Those symbols that we used to do basic mathematical operations are called arithmetic operators and the table below shows these operators:

## Arithmetic operators list in Java

In the table below, you can see the list of arithmetic operators.

 Operator Symbol Addition Operator + Subtraction Operator – Multiplication Operator * Division Operator / Modulus Operator % Increment Operator ++ Decrement Operator —

We use this operator to add two values (operands) together. These values can be a variable, constant values (like 1.22, 2, 3,4 etc.) or the result of expression or the returned value from a method call.

`LeftOperand + RightOperand;`

```public class Simple {
public static void main(String[] args){
int integer = 10;
int result = 2 + integer;
System.out.println(result);
}
}
```

Output: 12;

## Java Subtraction `-` Operator:

This operator is on the contrary to the addition operator and is used to subtract two operands (values) from each other. Just like addition operator, the operands can be either a constant value like (10, 4 ,2, 43.22 etc.), the result of calling a method or the value of a variable.

## Subtraction `-` Operator Syntax:

`LeftOperand - RightOperand;`

## Subtraction `-` Operator Example:

```public class Simple {
public static void main(String[] args){
int integer = 10;
int result = 2 - integer;
System.out.println(result);
}
}
```

Output:

-8

## Java Multiplication `*` operator:

When we want to multiply two values into each other, we use multiplication `*` operator. The values that can be used as the operands of the multiplication-operator can be the value assigned to a variable, constant values or the result of a method call.

## Multiplication `*` operator Syntax:

`LeftOperand * RightOperand;`

## Multiplication `*` operator Example:

```public class Simple {
public static void main(String[] args){
int integer = 20;
int result = integer * integer;
System.out.println(result);
}
}
```

Output: 400

## Java Division `/` operator:

On the contrary, to the multiplication operator, this operator is used to divide the operand on the left side by the operand on the right side of the division `/` operator. Just like multiplication operator, the values that are applicable to this operator are constant values, variables and the returned value from calling a method and also the result of an expression.

## Division `/` operator Syntax:

`LeftOperand / RightOperand;`

## Division `/` operator Example:

```public class Simple {
public static void main(String[] args){
int vOne = 100;
int vTwo = 200;
int result = vTwo / vOne;
System.out.println(result);
}
}
```

Output: 2

## Java Modulus `%` Operator:

Let me ask a question: how many 3 are in 10?

If you look carefully, it is 3. This is because if we multiply 3 to 4 we will get 12 which are two values over the number 10 but if we multiply 3 by 3 the result is 9. Now if we subtract the value 10 from 9 what’s the remainder? It is 1.

We use modulus operator to get that remainder.

## Modulus `%` Operator Syntax:

`LeftOperand % RightOperand;`

## Modulus `%` Operator Example:

```public class Simple {
public static void main(String[] args){
int result = 10 % 3;
System.out.println(result);
}
}
```

Output:

1

## Java Increment `++` Operator:

This operator is used to increase the value assigned to a variable by one.

This operator can be set on the left or right side of the target variable.

## Increment `++` Operator Syntax:

```++variable;

variable++;```

## Increment `++` Operator Example:

```public class Simple {
public static void main(String[] args){
int valueRight = 13;
int valueLeft = 13;
int left = ++valueLeft;
int right = valueRight++;

System.out.println("left-variable: "+ left+", right-variable: "+ right+", valueRight: "+ valueRight);
}
}
```

Output:

`left-variable: 14 , right-variable: 13, valueRight: 14`

## Here’s the difference:

If the `++` operator appeared on the left side of a variable like ` int left = ++valueLeft;` that means first increase the value assigned to the operand (in this case `valueLeft`) and then proceed to the rest of operations. So the assigned value to the `left` variable will be 14.

On the other hand, if the `++` operator appeared on the right side of a variable like ` int right = valueRight++;`, the value assigned to the operand (in this case `valueRight`) will be increased by one, but this is only guaranteed for the next time we call the target variable. So the final value that is assigned to the variable `right` in this example is 13 because the value of the `valueRight` did not change right away and the `right` variable took the old value stored in this variable.

## Java Decrement `–` Operator:

This operator is used to decrease the value assigned to a variable by one.

Notes:

• This operator can be set on the left and right side of the target variable.
• Rules that applied to `++` operator also apply to `–` operator as well.

## Decrement `–` Operator Syntax:

```--variable;

variable--;```

## Decrement `–` Operator Example:

```public class Simple {
public static void main(String[] args){
int valueRight = 13;
int valueLeft = 13;
int left = --valueLeft;
int right = valueRight-- + valueRight;

System.out.println("left-variable: "+ left+", right-variable: "+ right+", valueRight: "+ valueRight);
}
}
```

Output:

`left-variable: 12, right-variable: 25, valueRight: 12`

Note: The basic arithmetic operations mentioned in this section apply to operands from left to right.

For example, if we have `int res = 10/2; ` the value 10 is divided by 2 not vice versa!