## We’ll cover the following

- Arithmetic Operators
- The Modulus Operator
- Arithmetic Assignment Operators
- Increment and Decrement

Java provides a rich operator environment. Most of its operators can be divided

into the following four groups: arithmetic, bitwise, relational, and logical. Java also

defines some additional operators that handle certain special situations.

## Arithmetic Operators

Arithmetic operators are used in mathematical expressions in the same way that they are used in algebra. The following table lists the arithmetic operators:

Operator | Result |

+ | Addition |

– | 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 of a numeric type. You cannot use them on boolean types, but you can use them on char types, since the char type in Java is, essentially, a subset of int.

## The Basic Arithnmetic Operators

The basic arithmetic operations – addition, subtraction, multiplication, and division all behave as you would expect for all numeric types. The minus operator also has a unary from which negates its single operand. Remember that when the division operator is applied to an integer type, there will be no fractional components attached to the results.

The following simple example program demonstrates the arithmetic operators. It also illustrates the difference between floating-point division and integer division.

```
package JAVA.Basic;
// Demonstrate the basic arithmetic operators.
public class BasicMath {
public static void main(String args[]) {
// arithmetic using integers
System.out.println("Integer Arithmetic");
int a = 1 + 1;
int b = a * 3;
int c = b / 4;
int d = c - a;
int e = -d;
System.out.println("a = " + a);
System.out.println("b = " + b);
System.out.println("c = " + c);
System.out.println("d = " + d);
System.out.println("e = " + e);
// arithmetic using doubles
System.out.println("\nFloating Point Arithmetic");
double da = 1 + 1;
double db = da * 3;
double dc = db / 4;
double dd = dc - a;
double de = -dd;
System.out.println("da = " + da);
System.out.println("db = " + db);
System.out.println("dc = " + dc);
System.out.println("dd = " + dd);
System.out.println("de = " + de);
}
}
```

When you run this program, you will see the following output:

## The Modulus Operator

The modulus operator, %, returns the remainder of the a division operation.It can be applied to the floating-point types as well as integer types. (The differs from C/C++, in which the % can only be applied to integer types.) The following example program demonstrates the % :

```
package JAVA.Basic;
public class Modulus {
public static void main(String[] args) {
int x = 42;
double y = 42.25;
System.out.println("x mod 10 = " + x % 10);
System.out.println("y mod 10 = " + y % 10);
}
}
```

When you run this program you will get the following output:

## Arithmetic Assignment Operators

Java provides special operators that can be used to combine an arithmetic operation with an assignment. As you probably know, statements like the following are quite common in programming:

`a = a + 4;`

In Java, you can rewrite this statement as shown here:

`a += 4;`

This version uses the += assignment operator. Both statements perform the same

action: they increase the value of a by 4.

Here is another example,

`a = a % 2;`

which can be expressed as

`a %= 2;`

The assignment operators provide two benefits. First, they save you a bit of typing, because they are “shorthand” for their equivalent long forms. Second, they are implemented more efficiently by the Java run-time system than are their equivalent long forms. For these reasons, you will often see the assignment operators used in professionally written Java programs.

Here is a sample program that shows several op= operator assignments in action:

```
package JAVA.Basic;
public class OpEquals {
public static void main(String args[]) {
int a = 1;
int b = 2;
int c = 3;
a += 5;
b *= 4;
c += a * b;
c %= 6;
System.out.println("a = " + a);
System.out.println("b = " + b);
System.out.println("c = " + c);
}
}
```

The output of this program is shown here:

## Increment and Decrement

The ++ and the – – are Java’s increment and decrement operators. As you will see, they have some special properties that make them quite interesting. Let’s begin by reviewing precisely what the increment and decrement operators do.

The increment operator increases its operand by one. The decrement operator

decreases its operand by one. For example, this statement :

`x = x + 1;`

can be rewritten like this by use of the increment operator:

`x++;`

Similarly, this statement:

`x = x - 1;`

is equivalent to

`x--;`

These operators are unique in that they can appear both in postfix form, where they follow the operand as just shown, and prefix form, where they precede the operand. In the foregoing examples, there is no difference between the prefix and postfix forms. However, when the increment and/or decrement operators are part of a larger expression, then a subtle, yet powerful, difference between these two forms appears. In the prefix form, the operand is incremented or decremented before the value is obtained for use in the expression. In postfix form, the previous value is obtained for use in the expression, and then the operand is modified. For example:

```
x = 42;
y = ++x;
```

In this case, y is set to 43 as you would expect, because the increment occurs before x is assigned to y. Thus, the line y = ++x; is the equivalent of these two statements:

```
x = x + 1;
y = x;
```

However, when written like this,

```
x = 42;
y = x++;
```

the value of x is obtained before the increment operator is executed, so the value of y is 42. Of course, in both cases x is set to 43. Here, the line y = x++; is the equivalent of these two statements:

```
y = x;
x = x + 1;
```

The following program demonstrates the increment operator.

```
package JAVA.Basic;
public class IncDec {
public static void main(String args[]) {
int a = 1;
int b = 2;
int c;
int d;
c = ++b;
d = a++;
c++;
System.out.println("a = " + a);
System.out.println("b = " + b);
System.out.println("c = " + c);
System.out.println("d = " + d);
}
}
```

The output of this program follows:

That’s it!

You have successfully completed the post. Do Share : )

Peace Out!

**Also Read – ****Java Math Class**

**Check Out Deals on -> Amazon , Flipkart , Myntra , Adidas , Apple TV , Boat , Canva , Beardo , Coursera , Cleartrip , Fiverr , MamaEarth , Swiggy**

[…] Also Read – Java Arithmetic Operators […]