Différence entre les types primitifs `long` et `int` en Java

Utilisez int lorsque les valeurs attendues par votre programme restent dans sa plage ; choisissez long si elles peuvent être plus élevées. Ce sont deux types primitifs entiers signés. Leurs classes enveloppes, Integer et Long, sont des objets utilisés par les API et les collections qui fonctionnent avec des types référence. Les sections ci-dessous comparent leurs plages et la syntaxe des littéraux, puis expliquent dans quels cas une classe enveloppe est utile.

Choisir entre int et long en Java

Un int occupe 32 bits et représente des valeurs comprises entre -2,147,483,648 et 2,147,483,647. Un long occupe 64 bits et représente des valeurs comprises entre -9,223,372,036,854,775,808 et 9,223,372,036,854,775,807. Choisissez en fonction de la plage attendue pour vos données : le nom du type ne garantit pas à lui seul que chaque résultat d’un calcul pourra être représenté.

Un littéral entier décimal sans suffixe est généralement de type int s’il tient dans la plage de ce type. Ajoutez L pour en faire un littéral long, notamment si sa valeur dépasse la plage de int. Préférez le L majuscule, qui se distingue plus facilement du chiffre 1. Par exemple, long population = 9_000_000_000L; utilise un littéral long valide. Les caractères de soulignement facilitent la lecture sans modifier la valeur.

Exécutez cet exemple pour comparer une valeur int à une valeur long. Les libellés affichés dans l’exemple conservé à l’identique restent en anglais :

public class IntVsLongExample {
    public static void main(String[] args) {
        int count = 120;
        long total = 9_000_000_000L;
        System.out.println("count: " + count);
        System.out.println("total: " + total);
    }
}

count: 120
total: 9000000000

Pour comparer les erreurs à la compilation, int tooLarge = 2147483648; ne compile pas : ce littéral décimal dépasse la plage de int et ne porte pas le suffixe long. Écrivez plutôt long value = 2147483648L;. Le compilateur rejette la première déclaration avant l’exécution du programme ; elle ne produit donc aucune sortie à l’exécution. N’oubliez pas non plus qu’une expression int est évaluée comme un int, sauf si un opérande ou une conversion explicite fait passer le calcul en long. Affecter à un long un résultat déjà débordé ne permet pas de récupérer la valeur perdue.

Utiliser les classes enveloppes Integer et Long

Integer enveloppe un int, et Long enveloppe un long. Java peut convertir un type primitif en son type enveloppe, et inversement, grâce à l’autoboxing et à l’unboxing. Par exemple, Integer score = 42; convertit la valeur primitive en objet, tandis que int recordedScore = score; extrait la valeur primitive de l’objet. Les méthodes explicites intValue() et longValue() sont également disponibles lorsque rendre la conversion visible améliore la lisibilité.

Les classes enveloppes sont utiles lorsqu’une API exige des objets. Par exemple, les collections génériques telles que List<Integer> ne peuvent pas avoir un type primitif comme argument de type ; les valeurs ajoutées à cette liste sont donc converties en objets. Choisissez Long pour représenter un long sous forme d’objet, par exemple dans une List<Long>. Pour les calculs locaux ordinaires, les types primitifs sont généralement plus simples : les classes enveloppes ne sont pas nécessaires simplement pour appeler une méthode de conversion ou utilitaire.

La plage de la valeur enveloppée ne change pas : un Integer contient une valeur int, et un Long contient une valeur long. Une classe enveloppe ne permet pas de représenter un nombre supérieur à ce que son type primitif sous-jacent peut contenir. Utilisez L pour un littéral long, qu’il soit affecté à une variable long ou converti en objet Long.

Différences entre les types primitifs et les objets enveloppes

Une variable primitive stocke une valeur de son type primitif. Une variable de type enveloppe contient soit une référence vers un objet enveloppe, soit null. C’est cette distinction qui est utile en programmation ; présenter les objets enveloppes comme de simples pointeurs vers un espace de stockage numérique décrit incorrectement la mémoire physique et n’aide pas à choisir un type.

Les types primitifs ne peuvent pas être null. Une référence telle que Integer optionalCount = null; peut représenter l’absence de valeur, ce qui est utile lorsqu’une API ou un modèle de données distingue « non renseigné » de la valeur zéro. Il faut alors vérifier que la référence n’est pas null avant d’utiliser sa valeur. Si Java effectue l’unboxing d’un Integer ou d’un Long nul, l’opération déclenche une NullPointerException ; ne faites l’unboxing qu’après avoir vérifié que la référence désigne un objet.

En bref, choisissez int ou long selon la plage numérique nécessaire, puis utilisez Integer ou Long lorsque les API fondées sur des objets, les collections ou la possibilité de représenter une valeur absente justifient une classe enveloppe. Vous gardez ainsi distincts les calculs et la représentation des données manquantes.