0Pricing
Java Academy · Lezione

Aritmetica degli interi e overflow

Comprenda la divisione intera, il modulo, il comportamento dell'overflow e come rilevarlo.

Aritmetica degli interi e overflow è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Java Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Java Academy include 4 lezioni in totale.

Aritmetica degli interi e overflow

Gli interi Java hanno dimensioni fisse. Quando un calcolo supera il valore massimo o minimo, esegue un wrap-around silenzioso: non viene generata alcuna eccezione. Comprendere questo comportamento aiuta a prevenire errori difficili da individuare.

Intervalli degli interi

Ogni tipo intero ha un intervallo limitato determinato dalla propria ampiezza in bit:

  • byte: da -128 a 127
  • short: da -32.768 a 32.767
  • int: da -2.147.483.648 a 2.147.483.647
  • long: da -9,2 × 10^18 a 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: wrap-around silenzioso

Aggiungere 1 a Integer.MAX_VALUE produce un wrap-around fino a Integer.MIN_VALUE. Questa è un'aritmetica in complemento a due: Java non fornisce alcuna garanzia e non genera eccezioni.

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!

Rilevare l'overflow con Math.addExact

Java 8+ ha introdotto Math.addExact(), multiplyExact() e subtractExact(), che generano ArithmeticException in caso di overflow invece di eseguire un wrap-around silenzioso.

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

Divisione intera e resto

La divisione intera tronca verso zero. L'operatore % restituisce il resto con il segno del dividendo. Presti attenzione alla divisione per zero: genera 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

Aritmetica long per numeri grandi

Utilizzi long quando i valori possono superare l'intervallo di int. Aggiunga sempre L ai valori letterali long per evitare l'overflow prima dell'assegnazione.

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

Operatori di shift dei bit

Gli operatori di shift dei bit sono un modo rapido per moltiplicare o dividere per potenze di 2:

  • n << k — shift a sinistra: moltiplica per 2^k
  • n >> k — shift a destra con segno: divide per 2^k
  • n >>> k — shift a destra senza segno: riempie con zeri
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 e XOR bit a bit

Gli operatori bit a bit agiscono sui singoli bit e vengono utilizzati per permessi, flag e protocolli di basso livello.

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

Underscore nei valori numerici

Java 7+ consente di utilizzare underscore nei valori letterali numerici per migliorarne la leggibilità. Il compilatore li ignora.

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 per la precisione arbitraria

Quando i valori superano long, utilizzi BigInteger. Non presenta overflow, ma è più lento dei tipi primitivi. Lo utilizzi per chiavi crittografiche, fattoriali e numeri astronomici.

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

Esercitazione pratica: contatore a prova di overflow

Un modello per implementare un contatore che gestisce l'overflow in modo sicuro usando Math.addExact e ricorrendo a Long.MAX_VALUE in caso di overflow.

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

Verifica rapida

Qual è il valore della seguente espressione?

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

Riepilogo: aritmetica degli interi e overflow

Punti chiave:

  • L'overflow degli interi produce un ritorno ciclico silenzioso: per impostazione predefinita non viene lanciata alcuna eccezione
  • Usi Math.addExact/multiplyExact/subtractExact per rilevare l'overflow
  • La divisione tra interi tronca verso zero; il segno di % segue quello del dividendo
  • Usi valori letterali long (suffisso L) quando i risultati intermedi possono causare overflow di int
  • BigInteger gestisce valori arbitrariamente grandi senza overflow
  • Gli operatori di scorrimento dei bit sono alternative veloci alla moltiplicazione o divisione per potenze di 2

Domande Frequenti

La lezione «Aritmetica degli interi e overflow» è gratuita?

Sì — il testo completo di «Aritmetica degli interi e overflow» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Java Academy, passa a CoddyKit PRO. Il corso Java Academy include 4 lezioni in totale.

Cosa imparerò in «Aritmetica degli interi e overflow»?

Comprenda la divisione intera, il modulo, il comportamento dell'overflow e come rilevarlo. Eserciti Java Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Java Academy?

Non è richiesta alcuna esperienza precedente. Java Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Aritmetica degli interi e overflow»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Java Academy?

Sì. Ogni lezione Java Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Elementi essenziali della classe Math
  2. Aritmetica degli interi e overflow
  3. BigDecimal per i calcoli finanziari
  4. NumberFormat e printf
← Torna a Java Academy