Expand Authors Top

If you have a few years of experience in the Java ecosystem and you’d like to share that with the community, have a look at our Contribution Guidelines.

Expanded Audience – Frontegg – Security (partner)
announcement - icon User management is very complex, when implemented properly. No surprise here.

Not having to roll all of that out manually, but instead integrating a mature, fully-fledged solution - yeah, that makes a lot of sense.
That's basically what Frontegg is - User Management for your application. It's focused on making your app scalable, secure and enjoyable for your users.
From signup to authentication, it supports simple scenarios all the way to complex and custom application logic.

Have a look:

>> Elegant User Management, Tailor-made for B2B SaaS

November Discount Launch 2022 – Top
We’re finally running a Black Friday launch. All Courses are 30% off until the end of this week:

>> GET ACCESS NOW

November Discount Launch 2022 – TEMP TOP (NPI)
We’re finally running a Black Friday launch. All Courses are 30% off until the end of this week:

>> GET ACCESS NOW

1. Overview

Dividing by zero is an operation that has no meaning in ordinary arithmetic and is, therefore, undefined. In programming, however, while it is often associated with an error, this is not always the case.

In this article, we'll go through what happens when a division by zero occurs in a Java program.

According to the Java specification of the division operation, we can identify two different cases of division by zero: integers and floating-point numbers.

2. Integers

Firstly, for integers, things are pretty straightforward. Dividing an integer by zero will result in an ArithmeticException:

assertThrows(ArithmeticException.class, () -> {
    int result = 12 / 0;
});
assertThrows(ArithmeticException.class, () -> {
    int result = 0 / 0;
});

3. Floating Point Types

However, when dealing with floating-point numbers, an exception won't be thrown:

assertDoesNotThrow(() -> {
    float result = 12f / 0;
});

In order to handle cases like these, Java uses some special numeric values that can represent the results of such an operation: NaN, POSITIVE_INFINITY, and NEGATIVE_INFINITY.

3.1. NaN

Let's start by dividing floating-point zero values by zero:

assertEquals(Float.NaN, 0f / 0);
assertEquals(Double.NaN, 0d / 0);

The result in these cases is NaN (not a number).

3.2. Infinity

Next, let's divide some non-zero values by zero:

assertEquals(Float.POSITIVE_INFINITY, 12f / 0);
assertEquals(Double.POSITIVE_INFINITY, 12d / 0);
assertEquals(Float.NEGATIVE_INFINITY, -12f / 0);
assertEquals(Double.NEGATIVE_INFINITY, -12d / 0);

As we can see, the result is INFINITY, with the sign depending on the sign of the operands.

Moreover, we can also use the concept of negative zero in order to get to NEGATIVE_INFINITY:

assertEquals(Float.NEGATIVE_INFINITY, 12f / -0f);
assertEquals(Double.NEGATIVE_INFINITY, 12f / -0f);

3.3. Memory Representation

So, why does integer division by zero throw an exception, while floating-point division by zero does not?

Let's look at this from a memory representation perspective. For integers, there is no bit pattern that can be used to store the result of such an operation, while floating-point numbers have values like NaN or INFINITY to be used in cases like these.

Now, let's consider the binary representation of a float as SEEEEEEE EFFFFFFF FFFFFFFF FFFFFFFF with one bit (S) for the sign, 8 bits (E) for the exponent, and the rest (F) for the mantissa.

In each of the three values NaN, POSITIVE_INFINITY, and NEGATIVE_INFINITY, all bits in the exponent part are set to 1.

INFINITY has the mantissa bits all set to 0, while NaN has a non-zero mantissa:

assertEquals(Float.POSITIVE_INFINITY, Float.intBitsToFloat(0b01111111100000000000000000000000));
assertEquals(Float.NEGATIVE_INFINITY, Float.intBitsToFloat(0b11111111100000000000000000000000));
assertEquals(Float.NaN, Float.intBitsToFloat(0b11111111100000010000000000000000));
assertEquals(Float.NaN, Float.intBitsToFloat(0b11111111100000011000000000100000));

4. Summary

To sum things up, in this article we saw how division by zero works in Java.

Values like INFINITY and NaN are available for floating-point numbers but not for integers. As a result, dividing an integer by zero will result in an exception. However, for a float or double, Java allows the operation.

The complete code is available over on GitHub.

November Discount Launch 2022 – Bottom
We’re finally running a Black Friday launch. All Courses are 30% off until the end of this week:

>> GET ACCESS NOW

Generic footer banner
Comments are closed on this article!