Pembagian dengan Nol di Jawa: Pengecualian, Tak Terhingga, atau Bukan Angka

1. Ikhtisar

Membagi dengan nol adalah operasi yang tidak memiliki arti dalam aritmatika biasa dan, oleh karena itu, tidak ditentukan. Dalam pemrograman, bagaimanapun, meskipun sering dikaitkan dengan kesalahan, ini tidak selalu terjadi .

Pada artikel ini, kita akan membahas apa yang terjadi ketika pembagian dengan nol terjadi dalam program Java.

Menurut spesifikasi Java dari operasi pembagian, kita dapat mengidentifikasi dua kasus pembagian dengan nol: bilangan bulat dan bilangan floating-point.

2. Bilangan bulat

Pertama, untuk integer, semuanya cukup mudah. Membagi bilangan bulat dengan nol akan menghasilkan ArithmeticException :

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

3. Jenis Titik Mengambang

Namun, ketika berhadapan dengan bilangan floating-point , pengecualian tidak akan diberikan :

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

Untuk menangani kasus seperti ini, Java menggunakan beberapa nilai numerik khusus yang dapat mewakili hasil operasi tersebut: NaN , POSITIVE_INFINITY , dan NEGATIVE_INFINITY.

3.1. NaN

Mari kita mulai dengan membagi nilai nol floating-point dengan nol :

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

Hasil dalam kasus ini adalah NaN (bukan angka).

3.2. Infinity

Selanjutnya, mari bagi beberapa nilai bukan nol dengan nol :

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

Seperti yang bisa kita lihat, hasilnya adalah INFINITY, dengan tandanya tergantung dari tanda operannya.

Selain itu, kita juga dapat menggunakan konsep nol negatif untuk mencapai NEGATIVE_INFINITY :

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

3.3. Representasi Memori

Jadi, mengapa pembagian integer dengan nol memunculkan pengecualian, sedangkan pembagian floating-point dengan nol tidak?

Mari kita lihat ini dari perspektif representasi memori. Untuk bilangan bulat, tidak ada pola bit yang dapat digunakan untuk menyimpan hasil dari operasi semacam itu, sedangkan bilangan floating-point memiliki nilai seperti NaN atau INFINITY untuk digunakan dalam kasus seperti ini.

Sekarang, mari kita pertimbangkan representasi biner float sebagai S EEEEEEE E FFFFFFF FFFFFFFF FFFFFFFF dengan satu bit (S) untuk tanda, 8 bit (E) untuk eksponen, dan sisanya (F) untuk mantissa.

Di masing-masing dari tiga nilai NaN , POSITIVE_INFINITY, dan NEGATIVE_INFINITY, semua bit di bagian eksponen disetel ke 1.

INFINITY memiliki mantissa bit yang semuanya disetel ke 0, sedangkan NaN memiliki mantissa bukan nol:

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. Ringkasan

Singkatnya, dalam artikel ini kita melihat cara kerja pembagian dengan nol di Java.

Nilai seperti INFINITY dan NaN tersedia untuk bilangan floating-point tetapi tidak untuk bilangan bulat . Akibatnya, membagi integer dengan nol akan menghasilkan pengecualian. Namun, untuk float atau double , Java mengizinkan operasi tersebut.

Kode lengkapnya tersedia di GitHub.