Java Academy · Pelajaran

Aritmetik Integer dan Limpahan

Fahami pembahagian integer, modulus, tingkah laku limpahan dan cara mengesannya.

Pelajaran 2 daripada 413 langkah

Aritmetik Integer dan Limpahan ialah pelajaran Java Academy percuma di CoddyKit. Ini ialah pelajaran 2 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Java Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Java Academy merangkumi sejumlah 4 pelajaran.

Aritmetik Integer dan Limpahan

Integer Java mempunyai saiz tetap. Apabila pengiraan melebihi nilai maksimum atau minimum, nilainya berpusing semula secara senyap — tiada pengecualian dilemparkan. Memahami perkara ini dapat mencegah pepijat yang sukar dikesan.

Julat Integer

Setiap jenis integer mempunyai julat terhad 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

Limpahan: Pusingan Semula Senyap

Menambah 1 kepada Integer.MAX_VALUE menyebabkan nilainya berpusing menjadi Integer.MIN_VALUE. Ini ialah aritmetik pelengkap dua — Java tidak memberikan jaminan dan tidak mencetuskan 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!

Mengesan Limpahan dengan Math.addExact

Java 8+ memperkenalkan Math.addExact(), multiplyExact() dan subtractExact(), yang mencetuskan ArithmeticException apabila berlaku limpahan dan bukannya berpusing secara senyap.

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");
}

Pembahagian Integer dan Modulo

Pembahagian integer dipenggal ke arah sifar. Operator % memberikan baki dengan tanda yang sama seperti dividen. Berhati-hati terhadap pembahagian dengan sifar — ia mencetuskan 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

Aritmetik long untuk Nombor Besar

Gunakan long apabila nilai mungkin melebihi julat int. Sentiasa tambahkan L pada literal long untuk mengelakkan limpahan sebelum tugasan dilakukan.

// 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 Anjakan Bit

Operator anjakan bit ialah cara pantas untuk mendarab atau membahagi dengan kuasa 2:

n << k — anjakan kiri: darab dengan 2^k
n >> k — anjakan kanan bertanda: bahagi dengan 2^k
n >>> k — anjakan kanan tanpa tanda: isikan 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 dan XOR pada Bit

Operator bit berfungsi pada bit individu dan digunakan dalam keizinan, penanda serta protokol aras 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+ membenarkan garis bawah dalam literal numerik untuk meningkatkan kebolehbacaan. Garis bawah ini diabaikan oleh pengompil.

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 Ketepatan Sewenang-wenangnya

Apabila nilai melebihi long, gunakan BigInteger. Ia tidak mengalami limpahan tetapi lebih perlahan daripada jenis primitif. Gunakannya untuk kunci kriptografi, faktorial dan nombor astronomi.

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

Praktikal: Pembilang Selamat terhadap Limpahan

Satu corak untuk melaksanakan pembilang yang mengendalikan limpahan dengan selamat dengan menggunakan Math.addExact dan beralih kepada Long.MAX_VALUE sebagai pilihan sandaran.

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

Semakan Pantas

Apakah nilai ungkapan berikut?

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

Jawab dalam pelajaran interaktif

Imbas Kembali: Aritmetik Integer dan Limpahan

Perkara penting:

Limpahan integer berpusing semula secara senyap — tiada pengecualian secara lalai
Gunakan Math.addExact/multiplyExact/subtractExact untuk mengesan limpahan
Pembahagian integer dipenggal ke arah sifar; tanda % mengikut dividen
Gunakan literal long (akhiran L) apabila hasil perantaraan mungkin melimpahi int
BigInteger mengendalikan nilai yang besar tanpa had sewenang-wenangnya tanpa limpahan
Operator anjakan bit ialah alternatif pantas kepada pendaraban atau pembahagian dengan kuasa 2

Percuma untuk bermula

Pelajari Java dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 104
Pelajaran: 374

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Aritmetik Integer dan Limpahan” percuma?

Ya — teks penuh “Aritmetik Integer dan Limpahan” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Java Academy, tingkat taraf kepada CoddyKit PRO. Kursus Java Academy merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Aritmetik Integer dan Limpahan”?

Fahami pembahagian integer, modulus, tingkah laku limpahan dan cara mengesannya. Anda berlatih Java Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Java Academy?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Java Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 2 daripada 4.

Berapa lamakah pelajaran “Aritmetik Integer dan Limpahan” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Java Academy ini?

Ya. Setiap pelajaran Java Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke Java Academy