Java Academy · Pelajaran

Aritmetika Bilangan Bulat dan Overflow

Pahami pembagian bilangan bulat, modulus, perilaku overflow, dan cara mendeteksinya.

Aritmetika Bilangan Bulat dan Overflow adalah pelajaran Java Academy gratis di CoddyKit. Ini adalah pelajaran 2 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Java Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Java Academy mencakup 4 pelajaran total.

Aritmetika Bilangan Bulat dan Luapan

Bilangan bulat Java memiliki ukuran tetap. Jika perhitungan melebihi nilai maksimum atau minimum, nilainya berputar secara diam-diam—tidak ada pengecualian yang dilempar. Memahami hal ini membantu mencegah kesalahan yang sulit ditemukan.

Rentang Bilangan Bulat

Setiap tipe bilangan bulat memiliki rentang terbatas yang ditentukan oleh lebar bitnya:

byte: -128 hingga 127
short: -32.768 hingga 32.767
int: -2.147.483.648 hingga 2.147.483.647
long: -9,2 × 10^18 hingga 9,2 × 10^18

System.out.println(Integer.MAX_VALUE); // 2147483647
System.out.println(Integer.MIN_VALUE); // -2147483648
System.out.println(Long.MAX_VALUE);    // 9223372036854775807
System.out.println(Byte.MAX_VALUE);    // 127

Luapan: Perputaran Diam-Diam

Menambahkan 1 ke Integer.MAX_VALUE membuat nilainya berputar menjadi Integer.MIN_VALUE. Ini adalah aritmetika komplemen dua—Java tidak memberikan jaminan apa pun dan tidak melempar pengecualian.

int max = Integer.MAX_VALUE;
System.out.println(max + 1); // -2147483648 (overflow!)

byte b = 127;
b++;  // wraps to -128
System.out.println(b); // -128

// Real bug: counting votes in a large election with int
int votes = Integer.MAX_VALUE;
votes += 100; // silently wrong
System.out.println(votes); // negative number!

Mendeteksi Luapan dengan Math.addExact

Java 8+ memperkenalkan Math.addExact(), multiplyExact(), dan subtractExact() yang melempar ArithmeticException saat terjadi luapan, alih-alih berputar secara diam-diam.

try {
    int result = Math.addExact(Integer.MAX_VALUE, 1);
} catch (ArithmeticException e) {
    System.out.println("Overflow detected!"); // prints this
}

try {
    long safe = Math.multiplyExact(100_000L, 100_000L);
    System.out.println(safe); // 10000000000
} catch (ArithmeticException e) {
    System.out.println("Multiply overflow");
}

Pembagian dan Modulus Bilangan Bulat

Pembagian bilangan bulat memotong hasil menuju nol. Operator % memberikan sisa dengan tanda yang sama seperti bilangan yang dibagi. Waspadai pembagian dengan nol karena akan melempar ArithmeticException.

System.out.println(10 / 3);    // 3 (not 3.33)
System.out.println(10 % 3);    // 1
System.out.println(-10 % 3);   // -1 (sign follows dividend)
System.out.println(-10 % -3);  // -1

try {
    int x = 5 / 0; // ArithmeticException: / by zero
} catch (ArithmeticException e) {
    System.out.println(e.getMessage()); // / by zero
}

// Float division by zero gives Infinity, not exception
System.out.println(5.0 / 0); // Infinity

Aritmetika long untuk Bilangan Besar

Gunakan long jika nilai mungkin melebihi rentang int. Selalu tambahkan L pada literal long untuk mencegah luapan sebelum penugasan.

// Bug: multiplication done as int, then widened
long wrong = 1_000_000 * 1_000_000;   // overflows int!
System.out.println(wrong); // -727379968 (wrong!)

// Fix: one operand is long
long correct = 1_000_000L * 1_000_000L;
System.out.println(correct); // 1000000000000

// Or cast first
long alsOk = (long) 1_000_000 * 1_000_000;
System.out.println(alsOk); // 1000000000000

Operator Pergeseran Bit

Operator pergeseran bit merupakan cara cepat untuk mengalikan atau membagi dengan pangkat 2:

n << k — pergeseran kiri: mengalikan dengan 2^k
n >> k — pergeseran kanan bertanda: membagi dengan 2^k
n >>> k — pergeseran kanan tanpa tanda: mengisi dengan 0

int n = 8;
System.out.println(n << 1);  // 16 (8 * 2)
System.out.println(n << 2);  // 32 (8 * 4)
System.out.println(n >> 1);  // 4  (8 / 2)
System.out.println(n >> 2);  // 2  (8 / 4)

// Check if number is power of 2
boolean isPow2 = n > 0 && (n & (n - 1)) == 0;
System.out.println(isPow2); // true

AND, OR, XOR Berbasis Bit

Operator berbasis bit bekerja pada setiap bit dan digunakan dalam izin, tanda, serta protokol tingkat rendah.

int a = 0b1010; // 10
int b = 0b1100; // 12

System.out.println(Integer.toBinaryString(a & b)); // 1000 (AND = 8)
System.out.println(Integer.toBinaryString(a | b)); // 1110 (OR  = 14)
System.out.println(Integer.toBinaryString(a ^ b)); // 0110 (XOR = 6)
System.out.println(Integer.toBinaryString(~a));    // ...11110101 (NOT)

// Permission flags example
int READ  = 0b001;
int WRITE = 0b010;
int EXEC  = 0b100;
int perms = READ | WRITE; // user has read+write
System.out.println((perms & EXEC) != 0); // false — no exec

Garis Bawah dalam Literal Numerik

Java 7+ mengizinkan garis bawah dalam literal numerik untuk meningkatkan keterbacaan. Kompiler mengabaikannya.

int million = 1_000_000;
long creditCard = 4_111_1111_1111_1111L;
double pi = 3.141_592_653_589_793;
int hex = 0xFF_EC_D1_2E;
int binary = 0b0001_0101_0110;

System.out.println(million);   // 1000000
System.out.println(creditCard); // 4111111111111111

BigInteger untuk Presisi Tak Terbatas

Jika nilai melebihi long, gunakan BigInteger. Tipe ini tidak mengalami luapan, tetapi lebih lambat daripada tipe primitif. Gunakan untuk kunci kriptografi, faktorial, dan bilangan astronomis.

import java.math.BigInteger;

BigInteger factorial100 = BigInteger.ONE;
for (int i = 2; i <= 100; i++) {
    factorial100 = factorial100.multiply(BigInteger.valueOf(i));
}
System.out.println(factorial100.toString().length() + " digits"); // 158 digits

BigInteger a = new BigInteger("999999999999999999999999999999");
BigInteger b = new BigInteger("1");
System.out.println(a.add(b)); // 1000000000000000000000000000000

Praktik: Penghitung yang Aman dari Luapan

Pola untuk menerapkan penghitung yang menangani luapan dengan aman menggunakan Math.addExact dan beralih ke Long.MAX_VALUE jika terjadi luapan.

class SafeCounter {
    private long count = 0;

    public void increment() {
        try {
            count = Math.addExact(count, 1L);
        } catch (ArithmeticException e) {
            count = Long.MAX_VALUE; // cap at max
        }
    }

    public long get() { return count; }
}

SafeCounter sc = new SafeCounter();
sc.increment();
sc.increment();
System.out.println(sc.get()); // 2

Pemeriksaan Singkat

Berapakah nilai dari ekspresi berikut?

long result = 1_000_000 * 1_000_000;
System.out.println(result);

Rangkuman: Aritmetika Bilangan Bulat & Luapan

Hal-hal penting:

Luapan bilangan bulat berputar kembali secara diam-diam — secara bawaan tidak ada pengecualian
Gunakan Math.addExact/multiplyExact/subtractExact untuk mendeteksi luapan
Pembagian bilangan bulat memotong hasil menuju nol; tanda % mengikuti pembagi
Gunakan literal long (akhiran L) ketika hasil antara mungkin meluap dari int
BigInteger menangani nilai yang ukurannya tidak terbatas tanpa luapan
Operator pergeseran bit adalah alternatif cepat untuk perkalian/pembagian dengan pangkat 2

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Aritmetika Bilangan Bulat dan Overflow” gratis?

Ya — teks lengkap “Aritmetika Bilangan Bulat dan Overflow” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Java Academy, upgrade ke CoddyKit PRO. Kursus Java Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Aritmetika Bilangan Bulat dan Overflow”?

Pahami pembagian bilangan bulat, modulus, perilaku overflow, dan cara mendeteksinya. Kamu berlatih Java Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Java Academy?

Tidak diperlukan pengalaman sebelumnya. Java Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 4.

Berapa lama pelajaran “Aritmetika Bilangan Bulat dan Overflow” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Java Academy ini?

Ya. Setiap pelajaran Java Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Java Academy