Java Academy · leksjon

Heltallsaritmetikk og overflow

Forstå heltallsdivisjon, modulus, overflow-oppførsel og hvordan du oppdager overflow.

Leksjon 2 av 413 trinn

Heltallsaritmetikk og overflow er en gratis leksjon i Java Academy på CoddyKit. Dette er leksjon 2 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Java Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Java Academy inneholder totalt 4 leksjoner.

Heltallsaritmetikk og overflow

Java-heltall har faste størrelser. Når en beregning overskrider den høyeste eller laveste verdien, går den stille rundt – det kastes ikke noe unntak. Forståelse av dette hindrer vanskelige feil.

Heltallsområder

Hver heltallstype har et begrenset område som bestemmes av bitbredden:

byte: -128 til 127
short: -32,768 til 32,767
int: -2,147,483,648 til 2,147,483,647
long: -9.2 × 10^18 til 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

Overflow: Stille wrap-around

Å legge 1 til Integer.MAX_VALUE gir wrap-around til Integer.MIN_VALUE. Dette er tokomplementaritmetikk – Java gir ingen garanti og kaster ikke noe unntak.

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!

Oppdage overflow med Math.addExact

Java 8+ introduserte Math.addExact(), multiplyExact() og subtractExact(), som kaster ArithmeticException ved overflow i stedet for å gå stille rundt.

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

Heltallsdivisjon og modulus

Heltallsdivisjon avkortes mot null. Operatoren % gir resten med samme fortegn som dividenden. Vær oppmerksom på divisjon med null – det kaster 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

Long-aritmetikk for store tall

Bruk long når verdier kan overskride int-området. Legg alltid til L i long-litteraler for å hindre overflow før tilordningen.

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

Bitforskyvningsoperatorer

Bitforskyvningsoperatorer er raske måter å multiplisere eller dividere med potenser av 2 på:

n << k – venstreforskyvning: multipliserer med 2^k
n >> k – fortegnsbevarende høyreforskyvning: dividerer med 2^k
n >>> k – fortegnsuavhengig høyreforskyvning: fyller med 0-er

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

Bitvis AND, OR og XOR

Bitvise operatorer arbeider på individuelle biter og brukes i tillatelser, flagg og lavnivåprotokoller.

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

Understreker i numeriske litteraler

Java 7+ tillater understreker i numeriske litteraler for å gjøre dem mer lesbare. Kompilatoren ignorerer dem.

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 for vilkårlig presisjon

Når verdier overskrider long, bør De bruke BigInteger. Den har ingen overflow, men er tregere enn primitive typer. Bruk den for kryptografiske nøkler, fakulteter og astronomisk store tall.

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

Praktisk: Overflow-sikker teller

Et mønster for å implementere en teller som håndterer overflow på en trygg måte ved å bruke Math.addExact og falle tilbake til Long.MAX_VALUE.

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

Hurtigsjekk

Hva er verdien av følgende uttrykk?

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

Besvar den i den interaktive leksjonen

Oppsummering: Heltallsaritmetikk og overflow

Viktigste punkter:

Heltallsoverflow gir omslag uten at det kastes et unntak som standard
Bruk Math.addExact/multiplyExact/subtractExact for å oppdage overflow
Heltallsdivisjon forkaster desimaldelen mot null; fortegnet til % følger dividenden
Bruk heltallslitteraler av typen long (med suffikset L) når mellomresultater kan gi overflow i int
BigInteger håndterer vilkårlig store verdier uten overflow
Bitforskyvningsoperatorer er raske alternativer til multiplikasjon og divisjon med 2-potens

Gratis å komme i gang

Lær deg Java med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 104
Leksjoner: 374

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Heltallsaritmetikk og overflow» gratis?

Ja – hele teksten i «Heltallsaritmetikk og overflow» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Java Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Java Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Heltallsaritmetikk og overflow»?

Forstå heltallsdivisjon, modulus, overflow-oppførsel og hvordan du oppdager overflow. Du øver på Java Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Java Academy?

Ingen tidligere erfaring er nødvendig. Java Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 2 av 4.

Hvor lang tid tar leksjonen «Heltallsaritmetikk og overflow»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Java Academy-leksjonen?

Ja. Alle Java Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til Java Academy