### Arithmetic Operators in Java with Examples

In this chapter, we'll learn Arithmetic operators in Java programming language, their syntax, and how to use them with examples.

# 1. The 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:
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 an int.

# 2. The Basic Arithmetic Operators

The basic arithmetic operations — addition, subtraction, multiplication, and division — all behave as you would expect for all numeric types. The unary minus operator negates its single operand.
The following simple example program demonstrates the arithmetic operators. It also illustrates the difference between floating-point division and integer division.
```package net.javaguides.corejava.operators.arithmetic;

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);
}
}```
Output:
``````Integer Arithmetic
a = 2
b = 6
c = 1
d = -1
e = 1

Floating Point Arithmetic
da = 2.0
db = 6.0
dc = 1.5
dd = -0.5
de = 0.5
``````
Let's see one more example, the following program, ArithmeticDemo, tests the arithmetic operators.
```class ArithmeticDemo {

public static void main(String[] args) {

int result = 1 + 2;
// result is now 3
System.out.println("1 + 2 = " + result);
int original_result = result;

result = result - 1;
// result is now 2
System.out.println(original_result + " - 1 = " + result);
original_result = result;

result = result * 2;
// result is now 4
System.out.println(original_result + " * 2 = " + result);
original_result = result;

result = result / 2;
// result is now 2
System.out.println(original_result + " / 2 = " + result);
original_result = result;

result = result + 8;
// result is now 10
System.out.println(original_result + " + 8 = " + result);
original_result = result;

result = result % 7;
// result is now 3
System.out.println(original_result + " % 7 = " + result);
}
}```
This program prints the following:
``````1 + 2 = 3
3 - 1 = 2
2 * 2 = 4
4 / 2 = 2
2 + 8 = 10
10 % 7 = 3
``````
The + operator can also be used for concatenating (joining) two strings together, as shown in the following ConcatDemo program:
```class ConcatDemo {
public static void main(String[] args) {
String firstString = "This is";
String secondString = " a concatenated string.";
String thirdString = firstString + secondString;
System.out.println(thirdString);
}
}```
Output:
``This is a concatenated string.``

# 3. The Modulus Operator

The modulus operator, %, returns the remainder of a division operation. It can be applied to floating-point types as well as integer types.
The following example program demonstrates the %:
```package net.javaguides.corejava.operators.arithmetic;

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);
}
}```
Output:
``````x mod 10 = 2
y mod 10 = 2.25``````

# 4. Arithmetic Compound Assignment Operators

Java provides special operators that can be used to combine an arithmetic operation with an assignment. As we know that, 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 += compound assignment operator.
Here is a sample program that shows several op = assignments in action:
```package net.javaguides.corejava.operators.arithmetic;

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);
}
}```
Output:
``````a = 6
b = 8
c = 3``````

# 5. Increment and Decrement

The ++ and – – are Java’s increment and decrement operators.
The increment operator increases its operand by one.
For example:
``````x = x + 1; or x++;
``````
The decrement operator decreases its operand by one.
For example:
``````x = x - 1; or x--;
``````
The following program demonstrates the increment operator:
```package net.javaguides.corejava.operators.arithmetic;

public class IncrementDecrement {
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);
}
}```
Output:
``````a = 2
b = 3
c = 4
d = 1``````

# Free Spring Boot Tutorial | Full In-depth Course | Learn Spring Boot in 10 Hours

Watch this course on YouTube at Spring Boot Tutorial | Fee 10 Hours Full Course