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

CKTIS / Java

Le suffixe `L` des littéraux entiers en Java

`0L` est un zéro de type `long`, alors que `0` est de type `int`. Cette différence compte pour le choix d’une surcharge, les calculs et les valeurs par défaut de type `Long`.

Version : Java SE 21

Syntaxe

IntegerLiteral:
    DecimalNumeral [IntegerTypeSuffix]
    HexNumeral [IntegerTypeSuffix]
    OctalNumeral [IntegerTypeSuffix]
    BinaryNumeral [IntegerTypeSuffix]

IntegerTypeSuffix: L | l

En Java SE 21, un littéral entier valide sans suffixe est de type int ; avec L ou l, il est de type long. Le suffixe s’écrit juste après le dernier chiffre d’un nombre décimal, hexadécimal, octal ou binaire. Préférez L : le l minuscule se confond facilement avec 1. 0L et 0 ont la même valeur, mais pas le même type.

long timeout = 0; fonctionne par conversion élargissante de int vers long ; long timeout = 0L; utilise directement un littéral long. Le type de destination ne rend pas valide un littéral trop grand : 2_147_483_648 dans une affectation provoque une erreur de compilation, alors que 2_147_483_648L est valide. Sans L, cette grandeur décimale n’est admise que juste après le moins unaire (-2147483648) ; l’exception analogue pour long est -9223372036854775808L.

Si kind(int) et kind(long) sont disponibles, kind(0) appelle la surcharge int et kind(0L) la surcharge long. Le produit 1_000_000 * 3_000 est calculé en int et déborde même s’il est affecté à un long. Dans 1_000_000L * 3_000, l’autre opérande est promu en long avant la multiplication. Un calcul en long peut aussi déborder.

Pour Map<String, Long>, le deuxième argument de getOrDefault doit être compatible avec Long : 0L est converti en Long par boxing, alors que 0 serait converti en Integer. Pour cet appel, Java ne combine pas l’élargissement de int vers long avec le boxing vers Long. La méthode n’utilise la valeur par défaut que si la clé n’a pas d’association.

Exemples

import java.util.Map;

public class IntegerLiteralSuffixDemo {
    static String kind(int value) { return "int"; }
    static String kind(long value) { return "long"; }

    public static void main(String[] args) {
        long timeout = 0L;
        Map<String, Long> timeouts = Map.of("read", 2_147_483_648L);
        Long missing = timeouts.getOrDefault("write", 0L);

        System.out.println("timeout=" + timeout);
        System.out.println("kind(0)=" + kind(0));
        System.out.println("kind(0L)=" + kind(0L));
        System.out.println("read=" + timeouts.getOrDefault("read", 0L));
        System.out.println("write=" + missing);
        System.out.println("int product=" + (1_000_000 * 3_000));
        System.out.println("long product=" + (1_000_000L * 3_000));
    }
}

Résultat

timeout=0
kind(0)=int
kind(0L)=long
read=2147483648
write=0
int product=-1294967296
long product=3000000000

La clé `write` est absente, donc la méthode renvoie `0`. Les deux dernières lignes opposent le produit `int` avec débordement au produit `long` correct.

Leçons associées

  • Java · Leçon 30 · Avancé · Version : 2
  • Java · Leçon 31 · Avancé · Version : 2
  • Java · Leçon 43 · Avancé · Version : 2

Sources