Guida al tipo di dato long in Java: MAX/MIN, letterali con L, casting e sicurezza contro overflow

1. Cosa Imparerai in Questo Articolo (Conclusione Prima)

In Java, long è un tipo primitivo per gestire in modo sicuro interi grandi.
Tuttavia, ci sono alcuni punti di inciampo comuni per i principianti. In questo articolo, organizzeremo ciò che le persone che cercano java long vogliono probabilmente sapere in questo momento, e lo spiegheremo passo dopo passo in modo che tu possa capirlo in un ordine chiaro e logico.

1.1 Capire Rapidamente il Ruolo di long (“A cosa serve?” diventa chiaro)

long è un intero con segno a 64 bit, quindi può gestire numeri molto più grandi di int.
È per questo che viene comunemente usato in scenari come questi:

• ID (ad es., sequenze di database che possono crescere molto)
• Tempo (millisecondi in UNIX time, timestamp dei log, ecc.)
• Denaro (quando vuoi evitare i decimali e gestire gli importi come interi nell’unità più piccola)

In altre parole, se stai gestendo un intero che potrebbe crescere molto, long diventa estremamente importante.

1.2 Essere in Grado di Spiegare l’Intervallo di long (Max/Min) con Precisione

“Quanto grande può diventare un long?” è una domanda che sorge frequentemente anche nel lavoro reale.
In questo articolo, useremo Long.MAX_VALUE e Long.MIN_VALUE per spiegare come comprendere e gestire in modo sicuro l’intervallo.

Spiegheremo anche confusioni comuni come: “Perché dà errore anche se long dovrebbe essere in grado di contenere valori più grandi di int?”

1.3 Capire Perché i Letterali Numerici Hanno Bisogno di “L” (In Modo che Finalmente Abbia Senso)

Questa è la parte più ricercata e confusa di long:

• Cos’è la L in 123L ?
• Perché assegnare 3000000000 causa un errore?
• Quando dovresti aggiungere L ?

Partendo dal presupposto chiave che Java tratta i letterali interi come int per impostazione predefinita, spiegheremo attentamente perché L diventa necessario.
Una volta che questo ti sarà chiaro, la tua comprensione di long diventerà molto più stabile.

1.4 Imparare Come Funziona l’Overflow (e Come Prevenirlo)

long può gestire numeri grandi, ma non è infinito.
Se calcoli oltre il valore massimo, potresti vedere risultati che sembrano “sbagliati” (questo è l’overflow).

In questo articolo, copriremo:

• Esempi comuni in cui si verifica l’overflow
• Perché accade (senza entrare in dettagli eccessivamente difficili)
• Contromisure pratiche (come calcolare in modo sicuro)

…tutto spiegato in modo amichevole per i principianti.

1.5 Capire la Differenza Tra long e Long (Primitivo vs Wrapper)

Java ha sia long che Long.
Sembrano simili, il che li rende facili da confondere, ma servono scopi diversi.

• long : tipo primitivo (veloce, non può essere null )
• Long : classe (ha metodi, può contenere null )

Organizzeremo questa differenza in modo che tu la capisca come una vera decisione “come scegliere”, non solo qualcosa da memorizzare.

1.6 Il Tuo Obiettivo Dopo aver Letto Questo Articolo

Alla fine di questo articolo, dovresti essere in grado di:

• Decidere quando usare long e quando int è sufficiente
• Spiegare cosa significa L e correggere errori correlati da solo
• Usare Long.MAX_VALUE e costanti simili per gestire i confini in modo sicuro
• Evitare trappole di overflow e conversione di tipi nei calcoli intermedi
• Usare long vs Long in modo appropriato a seconda della situazione

Una volta arrivato qui, supererai “Sono un po’ insicuro su java long” e sarai in grado di scrivere codice con fiducia.

2. Cos’è il Tipo long di Java? (Definizione Base)

Da qui, solidificheremo i fondamenti del tipo long.
L’obiettivo è andare oltre “è un tipo che contiene numeri grandi” e capirlo correttamente come specifica del linguaggio.

2.1 long È un “Tipo Intero con Segno a 64 Bit”

In Java, long è un tipo intero con segno a 64 bit (8 byte).
“Con segno” significa che può rappresentare anche valori negativi.

Internamente, ha queste caratteristiche:

• Larghezza in bit: 64 bit
• Valori supportati: numeri positivi, zero e numeri negativi
• Nessun decimale (solo interi)

Essendo a 64 bit, long può gestire interi molto più grandi di int.

long a = 10;
long b = -500;
long c = 1234567890123L;

Tutti questi assegnamenti funzionano senza problemi.

2.2 Differenze rispetto a int, short e byte

Java ha diversi tipi interi oltre a long.
Organizziamo qui la “sensazione di dimensione”.

Nel lavoro reale, la regola pratica è:

• Calcoli normali → int
• Interi che potrebbero crescere molto → long

Questo è il modo standard di scegliere.

2.3 Perché non usare long per tutto fin dall’inizio?

Una domanda comune dei principianti è qualcosa del genere:

“Se long può contenere numeri più grandi, perché non usare long ovunque?”

Tecnicamente puoi, ma non è sempre la scelta migliore.

Ecco perché:

• int spesso ha un costo computazionale inferiore (è più facile da gestire per la CPU)
• Con array e grandi dataset, l’uso della memoria può variare
• Molte API Java sono progettate con int come ipotesi predefinita

Quindi, nella pratica:

• Se la dimensione è chiaramente piccola → usa int
• Se può crescere in futuro o potrebbe traboccare → usa long

Di solito questa è la decisione più realistica.

2.4 Casi d’uso reali comuni per long

long è frequentemente usato in situazioni come queste:

2.4.1 ID e numeri sequenziali

Le chiavi primarie del database o gli ID unici all’interno di un sistema possono, nel lungo periodo,
superare il limite superiore di int (circa 2,1 miliardi).

long userId = 10000000001L;

In casi come questo, long è quasi obbligatorio.

2.4.2 Tempo e date (timestamp)

In Java, il tempo è spesso gestito come un “intero in millisecondi”.

long now = System.currentTimeMillis();

Il tempo UNIX in millisecondi diventa un numero molto grande, quindi int non è affatto sufficiente.

2.4.3 Denaro (gestione dei valori nella più piccola unità)

Quando il denaro è gestito con double, gli errori di arrotondamento possono diventare un problema.
Perciò nei sistemi reali è comune gestire gli importi come interi nella “unità più piccola”.

// Manage in units of 1 yen
long price = 1500;

Questo è un altro caso d’uso classico per long.

2.5 long è “grande” ma non “infinito”

Ecco un avvertimento importante:

• long può contenere numeri grandi
• Ma non è infinito

Se un calcolo supera il limite superiore o inferiore, si verifica un overflow.
Ne parleremo in dettaglio in una sezione successiva.

3. Comprendere correttamente l’intervallo di long (Max/Min)

Quando si lavora con long, un punto da conoscere è l’“intervallo numerico”.
Se lo usi senza avere chiaro questo aspetto, possono sorgere bug inattesi e errori di calcolo.

3.1 Dove puoi controllare i valori massimo e minimo di long?

Java fornisce un modo sicuro per ottenere l’intervallo di long come costanti.

long max = Long.MAX_VALUE;
long min = Long.MIN_VALUE;

• Long.MAX_VALUE : il valore massimo rappresentabile da long
• Long.MIN_VALUE : il valore minimo rappresentabile da long

Non è necessario memorizzare questi numeri.
Ciò che conta è l’idea di “ottenerli nel codice”.

3.2 L’effettivo intervallo numerico di long

Per riferimento, l’intervallo di long in numeri è:

• Max: 9 223 372 036 854 775 807
• Min: –9 223 372 036 854 775 808

È un numero enorme di cifre e non molto intuitivo, ma è sufficiente ricordare:

• Può gestire fino a circa 9 quintilioni
• È su una scala completamente diversa rispetto a int (circa 2,1 miliardi)

Questo modello mentale è di solito sufficiente.

3.3 Perché i valori massimo e minimo sono asimmetrici?

Se osservi attentamente, l’intervallo di long sembra un po’ strano:

• Max: +9 223 372 036 854 775 807
• Min: –9 223 372 036 854 775 808

Ti potresti chiedere: “Perché il lato negativo è più grande di 1?”

Questo accade perché gli interi Java sono gestiti usando la rappresentazione in complemento a due.
Non è necessario pensarci troppo—basta ricordare:

Per progettazione, un valore extra è allocato sul lato negativo.

Questa comprensione è sufficiente.

3.4 Confrontare long con int

Now let’s compare it with int more concretely.

int intMax = Integer.MAX_VALUE;   // 2,147,483,647
long longMax = Long.MAX_VALUE;    // 9,223,372,036,854,775,807

Il massimo di int è circa 2,1 miliardi.
Al contrario, long ha un intervallo milioni di volte più grande.

A causa di questa differenza, valori come:

• conteggi
• tempo (millisecondi)
• totali cumulativi
• ID sequenziali

sono molto più propensi a superare ciò che int può contenere.

3.5 Attenzione nella gestione dei valori limite

Devi essere particolarmente attento vicino ai valori massimo e minimo di long.

long value = Long.MAX_VALUE;
value = value + 1;
System.out.println(value);

Se esegui questo codice, non si verifica alcun errore.
Tuttavia, il valore stampato non sarà quello che ti aspetti.

Questo fenomeno è chiamato overflow.

• Non appena il valore supera il limite superiore, si avvolge nella gamma negativa
• Java non genera automaticamente un errore per overflow

Se non conosci questo comportamento, è facile finire per pensare: “Perché è diventato improvvisamente negativo?”

3.6 Non “memorizzare” l’intervallo—“proteggilo”

Il concetto chiave è:

• Non memorizzare i numeri grezzi
• Usa Long.MAX_VALUE / Long.MIN_VALUE
• Fai attenzione ai calcoli che potrebbero superare i limiti

Mantenere questo approccio ridurrà notevolmente i problemi legati a long.

4. Perché il suffisso “L” è richiesto per i letterali numerici (Il punto più confuso)

Per chi cerca java long, l’argomento più confuso è spesso la “L” aggiunta ai letterali numerici.
Una volta compreso correttamente, molti errori e dubbi relativi a long scompaiono immediatamente.

4.1 In Java, i letterali interi sono int per impostazione predefinita

Prima di tutto, c’è un presupposto cruciale.
In Java, i letterali interi sono trattati come int per impostazione predefinita.

int a = 100;

Questo è ovviamente corretto.
Ma dai un’occhiata al codice seguente:

long b = 3000000000;

A prima vista sembra corretto, ma causa un errore di compilazione.

Il motivo è semplice:

• 3000000000 supera l’intervallo di int
• Java tenta prima di interpretarlo come int
• A quel punto, viene giudicato “troppo grande”

Ecco perché si verifica l’errore.

4.2 Cosa cambia quando aggiungi “L”?

Questo errore si risolve riscrivendo il codice così:

long b = 3000000000L;

Aggiungendo L alla fine del numero, indichi chiaramente a Java:

• “Questo valore è un letterale long.”
• “Trattalo come long fin dall’inizio, non come int.”

In breve, L è un marcatore che specifica esplicitamente il tipo.

4.3 Quando è richiesto “L”?

Hai bisogno di L nei seguenti casi:

4.3.1 Quando scrivi numeri che superano l’intervallo di int

long x = 2147483648L; // exceeds int max

In questo caso, L è obbligatorio.

4.3.2 Quando vuoi indicare esplicitamente un long

Anche se il valore è entro l’intervallo di int, potresti voler indicare chiaramente che dovrebbe essere trattato come long.

long count = 100L;

Non è obbligatorio, ma può migliorare la leggibilità.

4.4 È consentita la “l” minuscola?

Dal punto di vista della sintassi, è valido:

long y = 100l;

Tuttavia, la l minuscola non è consigliata.

I motivi sono semplici:

• È facile confonderla con la cifra “1”
• Può essere fraintesa durante le revisioni del codice

Ecco perché la regola comune è: usa sempre la L maiuscola.

4.5 Esadecimale, binario, underscore e L

I letterali long possono essere scritti anche in basi diverse dal decimale.

long hex = 0x7FFF_FFFF_FFFF_FFFFL;
long bin = 0b1010_1010_1010L;

Punti chiave:

• _ (underscore) può essere usato come separatore di cifre
• L è posizionato alla fine
• Questo migliora notevolmente la leggibilità per numeri grandi

4.6 “L” conta anche all’interno delle espressioni

Il codice seguente è una classica trappola per principianti:

long result = 1000 * 1000 * 1000;

Sebbene sembri corretto, tutti i calcoli intermedi vengono eseguiti come int.
Questo può causare overflow durante il calcolo.

La versione corretta è:

long result = 1000L * 1000 * 1000;

Aggiungendo L all’inizio, l’intera espressione viene valutata come long, rendendola sicura.

4.7 “L” Non Serve Solo per Evitare Errori

In sintesi, il ruolo di L è:

• Dire esplicitamente a Java “questo è un long ”
• Gestire in modo sicuro numeri oltre il range di int
• Prevenire overflow durante i calcoli intermedi
• Comunicare chiaramente l’intento ai lettori del codice

Pensalo non come un semplice simbolo, ma come un importante strumento per scrivere codice sicuro e leggibile.

5. Operazioni Base con long (Assegnazione, Calcolo, Casting)

Qui organizzeremo i punti chiave di assegnazione, aritmetica e conversione di tipo (casting) che emergono sempre quando si usa long.
È qui che i principianti spesso dicono: “Pensavo funzionasse, ma il risultato è strano”, quindi analizziamolo con attenzione.

5.1 Assegnazione Base a long

Le assegnazioni a long in generale appaiono così:

long a = 10;
long b = 100L;

• Valori entro il range di int → possono essere assegnati direttamente
• Valori oltre il range di int → richiedono L

Questo deriva direttamente da quanto coprato in precedenza.

5.2 Attenzione alla “Promozione di Tipo” nei Calcoli

Java ha una regola per cui il tipo usato nei calcoli intermedi è determinato automaticamente.
Se non lo capisci, può facilmente portare a bug sottili.

5.2.1 int × int Produce un int

Considera questo esempio:

long result = 1000 * 1000 * 1000;

L’ordine di elaborazione è:

1. 1000 * 1000 → risultato int
2. * 1000 → ancora int
3. Poi assegna il risultato a long

Poiché i passaggi intermedi rimangono come int, può verificarsi overflow prima dell’assegnazione.

5.2.2 Forza il Calcolo a Usare long dall’Inizio

Per evitarlo, è importante promuovere a long fin dall’inizio.

long result = 1000L * 1000 * 1000;

Questo garantisce:

• L’intera espressione viene valutata come long
• L’overflow intermedio viene evitato

Questo è l’approccio più sicuro.

5.3 Conversione di Tipo Implicita (Casi Sicuri)

In Java, le conversioni da un tipo più piccolo a uno più grande vengono eseguite automaticamente.

int x = 100;
long y = x;  // OK

Questo tipo di conversione è sicuro perché non si perde informazione.

5.4 Casi che Richiedono Casting Esplicito (Pericolosi)

D’altra parte, le conversioni di restringimento come long → int richiedono particolare cautela.

long big = 3000000000L;
int small = (int) big;

Questo codice compila, ma il valore non viene preservato correttamente.

• I bit di ordine superiore vengono troncati
• Il risultato diventa un numero completamente diverso

In altre parole, il casting non è “sicuro”—è “forzato”.

5.5 Come Decidere se il Casting è Appropriato

Un modo sicuro per pensare al casting è:

• “Il valore è garantito per entrare entro int ” → il casting può essere accettabile
• “Non so come potrebbe cambiare in futuro” → non castare
• “Valori al confine sono possibili” → mantienilo come long

Piuttosto che forzare i valori indietro in tipi più piccoli, è solitamente meglio continuare a usare un tipo abbastanza grande.

6. Comportamento dell’Overflow e Contromisure

long può gestire numeri molto grandi, ma una volta superati i suoi limiti, i problemi sono inevitabili.
Qui spiegheremo perché si verifica l’overflow e come prevenirlo, in modo amichevole per i principianti.

6.1 L’Overflow Può Verificarsi Anche con long

Innanzitutto, long è ancora un tipo finito.
Di conseguenza, codice come il seguente non causa un errore di compilazione, ma produce valori errati a runtime.

long value = Long.MAX_VALUE;
value = value + 1;
System.out.println(value);

Il risultato è un numero negativo molto grande, anche se hai solo aggiunto 1 al valore massimo.

Questo non è un bug—è esattamente come Java è specificato per comportarsi.

6.2 Perché il valore “si avvolge”?

Gli interi Java sono rappresentati internamente usando il complemento a due.
A causa di questa rappresentazione:

• Il valore massimo viene superato
• Il bit più significativo si inverte
• Il valore si avvolge nel range negativo

Il punto chiave è che Java non rileva automaticamente l’overflow.
Se non prendi precauzioni, potresti continuare a usare valori non validi senza accorgertene.

6.3 Situazioni tipiche in cui l’overflow diventa un problema

Devi essere particolarmente attento in scenari come questi:

• Calcoli monetari cumulativi
• Incrementare contatori o totali
• Calcoli temporali (somma di durate)
• Generazione automatica di ID o numeri di sequenza

Tutti questi valori tendono a crescere gradualmente, il che significa che possono eventualmente raggiungere il limite superiore durante un’operazione a lungo termine.

6.4 Calcolare in modo sicuro (usando Math.addExact, ecc.)

Java fornisce metodi che rilevano esplicitamente l’overflow.

long result = Math.addExact(a, b);

Questo metodo si comporta come segue:

• Se il risultato è entro l’intervallo long → restituisce normalmente
• Se supera l’intervallo → lancia ArithmeticException

Esistono anche metodi simili:

• Math.subtractExact
• Math.multiplyExact

Per i calcoli in cui la sicurezza è critica, questi metodi ti permettono di rilevare immediatamente condizioni anomale.

6.5 Controllare in anticipo con le istruzioni if

Puoi anche evitare eccezioni controllando le condizioni in anticipo.

if (value > Long.MAX_VALUE - add) {
    // Overflow may occur
}

Questo approccio è utile quando:

• Il codice viene eseguito molto frequentemente
• Vuoi evitare eccezioni per motivi di prestazioni

6.6 Cosa fare se long non è sufficiente?

Se:

• Il valore può superare l’intervallo long
• La precisione è estremamente importante (ad esempio, nei calcoli finanziari)

allora continuare a usare long non è la scelta giusta.

In tali casi, considera:

• BigInteger (interi a precisione arbitraria)
• BigDecimal (decimali a precisione arbitraria)

Scegliere di non “forzare” long è anche parte di un buon design.

7. La differenza tra long e Long (tipo primitivo vs classe wrapper)

Java ha due tipi dall’aspetto molto simile: long e Long.
Servono a scopi chiaramente diversi, e non comprendere come usarli correttamente può portare a bug o errori di progettazione.

7.1 Differenze fondamentali tra long e Long

Organizziamo prima le differenze.

In termini semplici:

• Scelta principale per i calcoli numerici → long
• Quando ti serve un oggetto → Long

Questa è l’idea di base.

7.2 Cos’è la classe Long?

Long è una classe che ti permette di trattare un valore long come un oggetto.

Long a = 10L;
Long b = Long.valueOf(20);

Usare Long ti consente di:

• Rappresentare null
• Usare metodi per conversione e confronto
• Memorizzare valori in collezioni (List, Map, ecc.)

7.3 Autoboxing e Unboxing

Java converte automaticamente tra long e Long.

Long a = 10L;   // Autoboxing (long → Long)
long b = a;    // Unboxing (Long → long)

Questo è comodo, ma comporta importanti avvertenze.

7.3.1 Attenzione a null e alle eccezioni runtime

Long a = null;
long b = a;  // NullPointerException

Se l’unboxing avviene quando un Long è null, viene lanciata un’eccezione runtime.

Pertanto:

• Il valore esiste sempre → long
• Il valore può mancare o non essere impostato → Long

Questa distinzione è estremamente importante.

7.4 Trappole di confronto (== vs equals)

Quando confronti oggetti Long, non dovresti usare ==.

Long a = 100L;
Long b = 100L;

System.out.println(a == b);      // May be true
System.out.println(a.equals(b)); // Always true

== confronta i riferimenti, mentre equals confronta i valori. Con Long, la cache interna può rendere il comportamento particolarmente confuso.

Usa sempre equals quando confronti valori.
Questa è la regola sicura.

7.5 Costanti e Metodi Comunemente Usati in Long

La classe Long fornisce funzionalità che sono frequentemente usate nella pratica.

Long.MAX_VALUE
Long.MIN_VALUE

Queste costanti sono essenziali per gestire in modo sicuro i limiti di long.

I metodi di conversione sono anch’essi molto comuni:

long x = Long.parseLong("123");
Long y = Long.valueOf("456");

• parseLong : restituisce un long primitivo
• valueOf : restituisce un oggetto Long

Scegli in base al tuo caso d’uso.

7.6 Come Decidere Quale Usare

Se non sei sicuro, usa queste linee guida:

• Calcoli e logica numerica → long
• Valori null possibili → Long
• Memorizzazione in collezioni → Long
• Codice sensibile alle prestazioni → long

Nella pratica, l’approccio più stabile è: usa long per impostazione predefinita e usa Long solo quando necessario.

8. Conversione Stringa ↔ long (Essenziale per Input, Configurazioni e Dati Esterni)

Nelle applicazioni reali, convertirai più spesso valori da stringhe a long rispetto a scriverli direttamente nel codice.

• Input di modulo
• Dati CSV o JSON
• File di configurazione
• Variabili d’ambiente

Qui organizzeremo metodi sicuri e corretti per convertire tra stringhe e long.

8.1 Stringa → long (Parsing di Numeri)

I due modi più comuni per convertire una stringa in long sono:

8.1.1 Uso di Long.parseLong (Il più comune)

long value = Long.parseLong("12345");

• Tipo di ritorno: long
• In caso di errore: lancia NumberFormatException

Questa è la scelta predefinita quando vuoi usare il valore nei calcoli.

8.1.2 Uso di Long.valueOf

Long value = Long.valueOf("12345");

• Tipo di ritorno: Long
• Può utilizzare una cache interna

È utile quando si memorizzano valori in collezioni o quando è necessario gestire null.

8.2 Gestione dei Fallimenti di Conversione ed Eccezioni

Le seguenti stringhe non riusciranno a essere convertite:

Long.parseLong("abc");
Long.parseLong("12.3");
Long.parseLong("");

Tutte queste lanciano NumberFormatException a runtime.

Quando si gestiscono input esterni, usa sempre il handling delle eccezioni:

try {
    long value = Long.parseLong(input);
} catch (NumberFormatException e) {
    // Handle invalid numeric input
}

Nella pratica, non dare mai per scontato che l’input sia sempre valido.

8.3 long → String (Per Visualizzazione e Output)

Esistono diversi modi per convertire valori long in stringhe.

8.3.1 Uso di Long.toString

long value = 12345;
String text = Long.toString(value);

Questo metodo è specifico per long e esprime chiaramente l’intento.

8.3.2 Uso di String.valueOf

String text = String.valueOf(value);

Questo approccio è anche comune e fornisce sicurezza per null.

8.4 Quale Metodo di Conversione Dovresti Scegliere?

Usa queste linee guida:

• Hai bisogno di un valore numerico per i calcoli → Long.parseLong
• Hai bisogno di un oggetto → Long.valueOf
• Visualizzazione o logging → String.valueOf / Long.toString

8.5 Punti Chiave da Ricordare Durante la Conversione

Tieni sempre a mente questi aspetti:

• Non fidarti ciecamente dell’input
• Scrivi il codice assumendo che possano verificarsi eccezioni
• Fai attenzione ai valori limite (MAX / MIN)
• Considera la crescita futura della lunghezza dei numeri

Seguire questi principi ridurrà notevolmente i bug legati alla conversione.

9. Casi d’Uso Pratici per long (Esempi del Mondo Reale)

Ora che abbiamo coperto i fondamenti, vediamo perché long è scelto nei sistemi reali, caso per caso.

9.1 Tempo UNIX e Timestamp

Un modo tipico per ottenere il tempo corrente in Java è:

long now = System.currentTimeMillis();

Il tempo UNIX in millisecondi supera già di gran lunga l’intervallo di int, quindi long è effettivamente lo standard.

• Timestamp di log
• Misurazione del tempo di esecuzione
• Gestione di scadenze e timeout

9.2 ID di Database e Chiavi Sequenziali

La maggior parte dei sistemi utilizza ID sequenziali per identificare i record.

long userId;
long orderId;

Su periodi di funzionamento prolungati:

• I conteggi dei record possono superare centinaia di milioni o miliardi
• Le espansioni future possono aumentare la lunghezza delle cifre

Utilizzare long fin dall’inizio riduce il rischio di dolorosi cambiamenti di tipo in seguito.

9.3 Gestione del Denaro (Evitando Errori di Punto Fluttuante)

Utilizzare double o float per il denaro può introdurre errori di arrotondamento.

Una soluzione comune è memorizzare gli importi nell’unità più piccola utilizzando long.

// Manage amounts in yen
long price = 1500;

• Addizione e sottrazione accurate
• Confronti più semplici
• Rilevamento overflow più facile

9.4 Contatori, Totali e Accumulatori

Valori che aumentano continuamente—come i conteggi di accesso—sono anch’essi buoni candidati per long.

long totalCount = 0;
totalCount++;

Anche se il valore inizia piccolo, scegliere long anticipa la crescita futura.

9.5 Valori Hash e Calcoli Interni

Negli algoritmi o nell’elaborazione interna, potresti aver bisogno di:

• Memorizzazione temporanea dei risultati dei calcoli
• Maggiore range rispetto a int, ma non precisione arbitraria

long spesso fornisce il giusto equilibrio.

9.6 È “Usa Solo long” Sempre Corretto?

Il punto chiave:

• Utilizzare long alla cieca non è sempre corretto
• Ma se il valore può crescere, è un forte candidato

Al momento della progettazione, semplicemente pensando a:

• Il valore massimo atteso
• Se il valore cresce nel tempo

rende la scelta molto più chiara.

10. (Avanzato) Trattare long come Non Firmato

Il long di Java è un intero con segno.
Se vuoi massimizzare il range non negativo, hai bisogno di un approccio diverso.

10.1 Java Non Ha un Tipo long Non Firmato

A differenza di C o C++, Java non fornisce un tipo long non firmato.
long utilizza sempre questo range:

• -9,223,372,036,854,775,808
• +9,223,372,036,854,775,807

10.2 Quando Vuoi Semantica Non Firmata

In pratica, potresti voler avere un comportamento non firmato in casi come:

• Risultati di operazioni bitwise
• Valori hash
• Numeri di protocollo di rete
• ID o token trattati come numeri grezzi

10.3 Utilizzo dei Metodi Non Firmati nella Classe Long

La classe Long fornisce metodi per operazioni non firmate:

Long.compareUnsigned(a, b);
Long.divideUnsigned(a, b);
Long.remainderUnsigned(a, b);

Questo permette:

• Mantenere la rappresentazione interna come long
• Applicare logica non firmata solo ai confronti o calcoli

10.4 Visualizzare Valori come Non Firmati

String text = Long.toUnsignedString(value);

Questo converte un valore in una stringa come se fosse non firmato.

10.5 Non Forzare l’Uso Non Firmato

Per dati aziendali tipici—denaro, conteggi, tempo—
long con segno è più sicuro e chiaro.

Pensa alla gestione non firmata come a uno strumento specializzato, non il default.

11. Riassunto (Punti Più Importanti Su long)

Riassumiamo i punti più importanti:

• long è un intero con segno a 64 bit
• Ideale per interi grandi (ID, tempo, denaro, ecc.)
• Usa Long.MAX_VALUE / Long.MIN_VALUE per gestire i range in sicurezza
• Aggiungi L ai letterali numerici quando richiesto
• Attenzione all’overflow basato su int durante i calcoli intermedi
• L’overflow può verificarsi anche con long
• Usa Math.addExact e metodi correlati per la sicurezza
• Default a long, usa Long solo quando necessario
• Non sottovalutare la conversione in stringa, i confini o la gestione delle eccezioni

Tenendo a mente questi punti ti aiuterà a evitare la maggior parte dei problemi relativi a long.

12. Domande Frequenti (FAQ)

12.1 D. Quali sono i valori massimo e minimo di long?

R.
Non devi memorizzare i numeri.
Usa queste costanti:

Long.MAX_VALUE;
Long.MIN_VALUE;

12.2 D. Il suffisso “L” è sempre richiesto?

R.
È richiesto per letterali numerici che superano il range di int.
È anche utile quando vuoi che i calcoli siano valutati come long.

12.3 D. L’overflow può verificarsi anche con long?

A.
Sì. Java non genera errori automaticamente.
Usa metodi come Math.addExact quando è importante la rilevazione.

12.4 Q. Devo usare long o Long?

A.
Usa long per impostazione predefinita.
Usa Long solo quando ti serve null o le collezioni.

12.5 Q. Qual è il modo corretto per convertire una stringa in long?

A.
L’approccio più comune è:

long value = Long.parseLong(str);

Ricorda sempre di gestire le eccezioni per input esterno.