Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / Java

Littéraux entiers en Java : `int`, `long` et `0L`

Découvrez quand un littéral entier est de type `int` ou `long`, comment écrire de grandes valeurs et pourquoi `0L` est utile pour cumuler des valeurs et les convertir en `Long`.

Version : Java SE 21

Syntaxe

IntegerLiteral ::= (DecimalNumeral | HexNumeral | OctalNumeral | BinaryNumeral) [IntegerTypeSuffix]
IntegerTypeSuffix ::= "L" | "l"
Examples: 0, 0L, 2_147_483_648L, 0x10L, 077L, 0b11L

En Java SE 21, 0L est le littéral décimal zéro de type primitif long (64 bits), tandis que 0 est de type int (32 bits). Le suffixe L ou l donne à un littéral entier le type long. Préférez L, car le l minuscule ressemble au chiffre 1. Avec les surcharges f(int) et f(long), f(0) choisit la première et f(0L) la seconde.

Les littéraux entiers s’écrivent en décimal (42), en hexadécimal (0x2A ou 0X2A), en octal (avec un zéro initial, comme dans 052) ou en binaire (0b101010 ou 0B101010). Les tirets bas séparent les chiffres, comme dans 2_147_483_648L ou 0_52. Ils ne peuvent figurer ni juste après un préfixe hexadécimal ou binaire, ni après le dernier chiffre, même avant L.

Le type de destination ne change pas celui du littéral : long n = 2_147_483_648; ne compile pas, alors que long n = 2_147_483_648L; est valide. Les littéraux décimaux limites 2147483648 et 9223372036854775808L ne sont autorisés que comme opérandes du moins unaire -. En hexadécimal, en octal et en binaire, le bit de poids fort du type est le bit de signe : 0xFFFF_FFFF représente -1 de type int, tandis que 0xFFFF_FFFFL représente la valeur positive 4294967295L. Une écriture qui exige plus de 32 bits pour int ou plus de 64 bits pour long provoque une erreur de compilation.

long total = 0L; initialise explicitement un cumul de type long à zéro. long total = 0; fonctionne aussi : le int est converti en long par élargissement. Dans total + 1, 1 est élargi avant l’addition. Mais stocker un résultat dans un long n’empêche pas le débordement d’un calcul en int : long n = 2_000_000_000 + 2_000_000_000; donne -294967296. Ajoutez L à l’un des deux opérandes pour effectuer l’addition en long. Un débordement en long ne lève pas non plus d’exception.

Long boxed = 0L; encapsule la valeur primitive dans un java.lang.Long (boxing). Long boxed = 0; ne compile pas : une affectation ne combine pas l’élargissement de int vers long avec le boxing vers Long. long n = boxed; et boxed + 1 extraient tous deux la valeur long (unboxing). Si boxed vaut null, cette extraction lève une NullPointerException.

Exemples

public class Main {
    public static void main(String[] args) {
        long total = 0L;
        total += 2_147_483_648L;
        total += 0x10 + 0b11 + 07;

        Long boxed = total;
        long next = boxed + 1;
        System.out.println(total);
        System.out.println(next);
    }
}

Résultat

2147483674
2147483675

`0x10`, `0b11` et `07` donnent la valeur `26` de type `int`, élargie en `long` dans `total += ...`. L’affectation à `boxed` encapsule le total, et `boxed + 1` extrait sa valeur avant l’addition.

Leçons associées

  • Java · Leçon 39 · Avancé · Version : 2

Sources