The division operator (/) is used in the form
operand1 / operand2
The division operator computes the quotient of two numbers.
There are two types of division in Java:
If both the operands of the division operator are integers, that is, byte, short, char, int, or long, the division is done and decimal part is removed to represent an integer.
For example, 5/2 yields 2.5; the fractional part 0.5 is ignored; and the result is 2.
The following examples illustrate the integer division:
int num; num = 5/2; // Assigns 2 to num num = 5/3; // Assigns 1 to num num = 5/4; // Assigns 1 to num num = 5/5; // Assigns 1 to num num = 5/6; // Assigns 0 to num num = 5/7; // Assigns 0 to num
public class Main { public static void main(String[] args) { int num; // w ww. ja v a2s. co m num = 5/2; // Assigns 2 to num System.out.println(num); num = 5/3; // Assigns 1 to num System.out.println(num); num = 5/4; // Assigns 1 to num System.out.println(num); num = 5/5; // Assigns 1 to num System.out.println(num); num = 5/6; // Assigns 0 to num System.out.println(num); num = 5/7; // Assigns 0 to num System.out.println(num); } }
If either of the operands are float or double type, floating-point division is performed and the result is not truncated.
public class Main { public static void main(String[] args) { float f1; //from w w w. j av a 2s. c o m f1 = 15.0F/4.0F; System.out.println(f1); f1 = 15/4.0F; System.out.println(f1); } }
In the following code, 15.0 is of the type double and 4.0F is of the type float. The expression 15.0/4.0F is of type double. The result 3.75 is of the type double and cannot be assigned to f1.
f1 = 15.0/4.0F; // An error.
To fix the error, add casting
f1 = (float)(15.0/4.0F); // Ok. 3.75F is assigned to f1
In the following code, 15 and 4 are of the type int. The expression 15/4 is of type int. An integer division is performed. The result 3 is assigned to f1. int to float assignment is allowed.
float f1 = 15/4;
public class Main { public static void main(String[] args) { float f1; /*ww w .j a v a 2s . c o m*/ f1 = 15/4; System.out.println(f1); } }
The result of dividing a number by zero depends on the type of division.
If an integer division is performed on the number, dividing by zero results in a runtime error.
If you write expression 3/0 in a Java program, it compiles fine, but it gives error when it is executed at runtime. For example,
int i = 2; int j = 5; int k = 0; i = j/k; // A runtime error. Divide by zero i = 0/0; // A runtime error. Divide by zero
public class Main { public static void main(String[] args) { int i = 2; //from ww w. j a va 2 s. c o m int j = 5; int k = 0; i = j/k; // A runtime error. Divide by zero i = 0/0; // A runtime error. Divide by zero System.out.println(i); } }
If either operand of the division operator is a floating-point number, a floating-point division is performed.
The result of dividing by zero is not an error. If the dividend is a non-zero number in a floating-point divide-by-zero operation, the result is either positive infinity or a negative infinity.
If the dividend is a floating-point zero (e.g. 0.0 or 0,0F), the result is NaN. For example,
float f1 = 0F; double d1 = 0.0; f1 = 5.0F/0.0F; // Float.POSITIVE_INFINITY is assigned to f1 f1 = -5.0F/0.0F; // Float.NEGATIVE_INFINITY is assigned to f1 f1 = -5.0F/-0.0F; // Float.POSITIVE_INFINITY is assigned to f1 f1 = 5.0F/-0.0F; // Float.NEGATIVE_INFINITY is assigned to f1 d1 = 5.0/0.0; // Double.POSITIVE_INFINITY is assigned to d1 d1 = -5.0/0.0; // Double.NEGATIVE_INFINITY is assigned to d1 d1 = -5.0/-0.0; // Double.POSITIVE_INFINITY is assigned to d1 d1 = 5.0/-0.0; // Double.NEGATIVE_INFINITY is assigned to d1
public class Main { public static void main(String[] args) { float f1 = 0F; double d1 = 0.0; /* ww w. ja v a 2 s . co m*/ f1 = 5.0F/0.0F; // Float.POSITIVE_INFINITY is assigned to f1 System.out.println(f1); f1 = -5.0F/0.0F; // Float.NEGATIVE_INFINITY is assigned to f1 System.out.println(f1); f1 = -5.0F/-0.0F; // Float.POSITIVE_INFINITY is assigned to f1 System.out.println(f1); f1 = 5.0F/-0.0F; // Float.NEGATIVE_INFINITY is assigned to f1 System.out.println(f1); d1 = 5.0/0.0; // Double.POSITIVE_INFINITY is assigned to d1 System.out.println(d1); d1 = -5.0/0.0; // Double.NEGATIVE_INFINITY is assigned to d1 System.out.println(d1); d1 = -5.0/-0.0; // Double.POSITIVE_INFINITY is assigned to d1 System.out.println(d1); d1 = 5.0/-0.0; // Double.NEGATIVE_INFINITY is assigned to d1 System.out.println(d1); } }
f1 = 0.0F/0.0F; // Assigns Float.NaN to f1 d1 = 0.0/0.0; // Assigns Double.NaN to d1 d1 = -0.0/0.0; // Assigns Double.NaN to d1
public class Main { public static void main(String[] args) { float f1 = 0.0F/0.0F; // Assigns Float.NaN to f1 System.out.println(f1);/*from w w w . j av a2 s. com*/ double d1 = 0.0/0.0; // Assigns Double.NaN to d1 System.out.println(d1); d1 = -0.0/0.0; // Assigns Double.NaN to d1 System.out.println(d1); } }
In the following code, 5.0F is of the type float and 0 is of the type int. 5.0F/0 is of type float. Float.POSITIVE_INFINITY is assigned to f1
float f1 = 5.0F/0;
public class Main { public static void main(String[] args) { float f1 = 5.0F/0; System.out.println(f1);/*from w w w .j ava2s .com*/ } }
In the following code, 5.0F is of the type float and 0.0 is of the type double 5.0F/0.0 is of the type double. double to float assignment is not allowed.
float f1 = 5.0F/0.0; // A compile-time error.
To fix the error, add casting.
float f1 = (float)(5.0F/0.0); // f1 is assigned Float.POSITIVE_INFINITY