Java Language
Littéraux

Introduction

Littéraux hexadécimaux, octaux et binaires

Un nombre hexadecimal est une valeur de base-16. Il y a 16 chiffres, 0-9 et les lettres AF (la casse n'a pas d'importance). AF représente 10-16 .

Un nombre octal est une valeur en base 8 et utilise les chiffres 0-7 .

Un nombre binary est une valeur de base-2 et utilise les chiffres 0 et 1 .

Tous ces nombres donnent la même valeur, 110 :

int dec = 110;            // no prefix   --> decimal literal
int bin = 0b1101110;      // '0b' prefix --> binary literal
int oct = 0156;           // '0' prefix  --> octal literal
int hex = 0x6E;           // '0x' prefix --> hexadecimal literal

Notez que la syntaxe littérale binaire a été introduite dans Java 7.

Le littéral octal peut facilement être un piège pour les erreurs sémantiques. Si vous définissez un '0' vos littéraux décimaux, vous obtiendrez une valeur incorrecte:

int a = 0100;        // Instead of 100, a == 64

Utiliser le soulignement pour améliorer la lisibilité

Depuis Java 7, il est possible d'utiliser un ou plusieurs traits de soulignement (_) pour séparer des groupes de chiffres dans un littéral de nombre primitif afin d'améliorer leur lisibilité.

Par exemple, ces deux déclarations sont équivalentes:

int i1 = 123456;
int i2 = 123_456;
System.out.println(i1 == i2); // true

Cela peut être appliqué à tous les littéraux de nombres primitifs comme indiqué ci-dessous:

byte color = 1_2_3;
short yearsAnnoDomini= 2_016;
int socialSecurtyNumber = 999_99_9999;
long creditCardNumber = 1234_5678_9012_3456L;
float piFourDecimals =  3.14_15F;
double piTenDecimals =  3.14_15_92_65_35;

Cela fonctionne également en utilisant des préfixes pour les bases binaires, octales et hexadécimales:

short binary= 0b0_1_0_1;
int octal = 07_7_7_7_7_7_7_7_0;
long hexBytes = 0xFF_EC_DE_5E;

Il y a quelques règles sur les soulignés qui interdisent leur placement dans les endroits suivants:

• Au début ou à la fin d'un nombre (par exemple, _123 ou 123_ ne sont pas valides)
• Adjacent à un point décimal dans un littéral à virgule flottante (par exemple, 1._23 ou 1_.23 ne sont pas valides)
• Avant un suffixe F ou L (par exemple, 1.23_F ou 9999999_L ne sont pas valides)
• Dans les positions où une chaîne de chiffres est attendue (par exemple, 0_xFFFF n'est pas valide)

Séquences d'échappement dans les littéraux

Les littéraux de chaîne et de caractère fournissent un mécanisme d'échappement qui permet des codes de caractères express qui ne seraient pas autorisés dans le littéral. Une séquence d'échappement consiste en une barre oblique inverse ( \ ) suivie d'un ou plusieurs autres caractères. Les mêmes séquences sont valables dans les deux caractères et les chaînes de caractères.

L'ensemble complet des séquences d'échappement est le suivant:

Le <octal> ci-dessus consiste en un, deux ou trois chiffres octaux ("0" à "7") qui représentent un nombre compris entre 0 et 255 (décimal).

Notez qu'une barre oblique inverse suivie de tout autre caractère est une séquence d'échappement non valide. Les séquences d'échappement non valides sont traitées comme des erreurs de compilation par le JLS.

Référence:

• JLS 3.10.6. Séquences d'échappement pour les littéraux de caractères et de chaînes

Unicode s'échappe

En plus des séquences d'échappement de chaînes et de caractères décrites ci-dessus, Java possède un mécanisme d'échappement Unicode plus général, tel que défini dans JLS 3.3. Unicode s'échappe . Une sortie Unicode a la syntaxe suivante:

'\' 'u' <hex-digit> <hex-digit> <hex-digit> <hex-digit> 

où <hex-digit> est l'un de '0' , '1' , '2' , '3' , '4' , '5' , '6' , '7' , '8' , '9' , 'a' , 'b' , 'c' , 'd' , 'e' , 'f' , 'A' , 'B' , 'C' , 'D' , 'E' , 'F' .

Un échappement Unicode est mappé par le compilateur Java sur un caractère (à proprement parler une unité de code Unicode 16 bits) et peut être utilisé n'importe où dans le code source où le caractère mappé est valide. Il est couramment utilisé dans les littéraux de caractères et de chaînes lorsque vous devez représenter un caractère non-ASCII dans un littéral.

S'échapper dans les regexes

À déterminer

Littéraux décimaux entiers

Fournissent des valeurs des entiers qui peuvent être utilisés lorsque vous avez besoin d' un byte , short , int , à long ou char par exemple. (Cet exemple se concentre sur les formes décimales simples. D'autres exemples expliquent comment utiliser les littéraux en octal, hexadécimal et binaire, et l'utilisation de traits de soulignement pour améliorer la lisibilité.)

Littéraux entiers ordinaires

La forme la plus simple et la plus commune de littéral entier est un littéral entier décimal. Par exemple:

 0       // The decimal number zero       (type 'int')
 1       // The decimal number one        (type 'int')
 42      // The decimal number forty two  (type 'int')

Vous devez faire attention aux premiers zéros. Un zéro en tête entraîne l'interprétation d'un littéral entier en octal et non en décimal.

 077    // This literal actually means 7 x 8 + 7 ... or 63 decimal!

Les littéraux entiers sont non signés. Si vous voyez quelque chose comme -10 ou +10 , ce sont en fait des expressions en utilisant les unaire - et unaires + opérateurs.

La plage de littéraux entiers de cette forme a un type intrinsèque de int et doit être comprise entre zéro et 2 ³¹ ou 2 147 483 648.

Notez que 2 ³¹ est 1 supérieur à Integer.MAX_VALUE . Littéraux de 0 à à 2147483647 peut être utilisé partout, mais il est une erreur de compilation à utiliser 2147483648 sans précédent unaire - opérateur. (En d'autres termes, il est réservé pour exprimer la valeur de Integer.MIN_VALUE .)

 int max = 2147483647;     // OK
 int min = -2147483648;    // OK
 int tooBig = 2147483648;  // ERROR

Littéraux entiers longs

Les littéraux de type long sont exprimés en ajoutant un suffixe L Par exemple:

 0L          // The decimal number zero       (type 'long')
 1L          // The decimal number one        (type 'long')
 2147483648L // The value of Integer.MAX_VALUE + 1

 long big = 2147483648;    // ERROR
 long big2 = 2147483648L;  // OK

Notez que la distinction entre littéraux int et long est significative à d'autres endroits. Par exemple

 int i = 2147483647;
 long l = i + 1;           // Produces a negative value because the operation is
                           // performed using 32 bit arithmetic, and the 
                           // addition overflows
 long l2 = i + 1L;         // Produces the (intuitively) correct value.

Référence: JLS 3.10.1 - Littéraux entiers

Littéraux booléens

Les littéraux booléens sont les littéraux les plus simples du langage de programmation Java. Les deux valeurs boolean possibles sont représentées par les littéraux true et false . Ceux-ci sont sensibles à la casse. Par exemple:

boolean flag = true;    // using the 'true' literal
flag = false;           // using the 'false' literal

Littéraux de chaîne

Les littéraux de chaîne constituent le moyen le plus pratique de représenter des valeurs de chaîne dans le code source Java. Un littéral de chaîne se compose de:

• Un caractère de guillemet double ( " ).
• Zéro ou plusieurs autres caractères qui ne sont ni des guillemets doubles ni des sauts de ligne. (Un caractère barre oblique inverse ( \ ) modifie la signification des caractères suivants; voir Séquences d'échappement dans les littéraux .)
• Un caractère de guillemet double.

Par exemple:

"Hello world"   // A literal denoting an 11 character String
""              // A literal denoting an empty (zero length) String
"\""            // A literal denoting a String consisting of one 
                //     double quote character
"1\t2\t3\n"     // Another literal with escape sequences

Notez qu'un littéral de chaîne unique peut ne pas couvrir plusieurs lignes de code source. C'est une erreur de compilation pour qu'un saut de ligne (ou la fin du fichier source) survienne avant le double guillemet de fermeture d'un littéral. Par exemple:

"Jello world    // Compilation error (at the end of the line!)

Cordes longues

Si vous avez besoin d'une chaîne trop longue pour tenir sur une ligne, la façon conventionnelle de l'exprimer est de la diviser en plusieurs littéraux et d'utiliser l'opérateur de concaténation ( + ) pour les joindre. Par exemple

String typingPractice = "The quick brown fox " +
                        "jumped over " +
                        "the lazy dog"

Une expression comme ci-dessus constituée de chaînes littérales et de + satisfait aux exigences pour être une expression constante . Cela signifie que l'expression sera évaluée par le compilateur et représentée à l'exécution par un seul objet String .

Interning des littéraux de chaîne

Lorsque le fichier de classe contenant des littéraux de chaîne est chargé par la machine virtuelle Java, les objets String correspondants sont internés par le système d'exécution. Cela signifie qu'un littéral de chaîne utilisé dans plusieurs classes n'occupe pas plus d'espace que s'il était utilisé dans une classe.

Pour plus d'informations sur l'internement et le pool de chaînes, reportez-vous à l'exemple du pool de chaînes et du stockage de segments dans la rubrique Chaînes.

Le littéral nul

Le littéral Null (écrit en tant que null ) représente la valeur unique du type NULL. Voici quelques exemples

    MyClass object = null;
    MyClass[] objects = new MyClass[]{new MyClass(), null, new MyClass()};

    myMethod(null);

    if (objects != null) {
         // Do something
    }

Le type null est plutôt inhabituel. Il n'a pas de nom, vous ne pouvez donc pas l'exprimer en code source Java. (Et il n'a pas de représentation à l'exécution non plus.)

Le seul but du type null est d’être le type de null . Il est compatible avec tous les types de référence et peut être converti en type de référence. (Dans ce dernier cas, le cast n'implique pas de vérification du type à l'exécution.)

Enfin, null a la propriété que null instanceof <SomeReferenceType> évaluera à false , quel que soit le type.

Littéraux à virgule flottante

Les littéraux à virgule flottante fournissent des valeurs pouvant être utilisées lorsque vous avez besoin d'une instance float ou double . Il existe trois types de littéraux à virgule flottante.

• Formes décimales simples
• Formes décimales mises à l'échelle
• Formes hexadécimales

(Les règles de syntaxe JLS combinent les deux formes décimales en un seul formulaire. Nous les traitons séparément pour faciliter l'explication.)

Il existe des types littéraux distincts pour les littéraux float et double , exprimés en utilisant des suffixes. Les différentes formes utilisent des lettres pour exprimer différentes choses. Ces lettres sont insensibles à la casse.

Formes décimales simples

La forme la plus simple du littéral à virgule flottante consiste en un ou plusieurs chiffres décimaux et un point décimal ( . ) Et un suffixe facultatif ( f , F , d ou D ). Le suffixe facultatif vous permet de spécifier que le littéral est une valeur float ( f ou F ) ou double ( d ou D ). La valeur par défaut (quand aucun suffixe n'est spécifié) est double .

Par exemple

 0.0     // this denotes zero
 .0      // this also denotes zero
 0.      // this also denotes zero
 3.14159 // this denotes Pi, accurate to (approximately!) 5 decimal places.
 1.0F    // a `float` literal
 1.0D    // a `double` literal.  (`double` is the default if no suffix is given)

En fait, les chiffres décimaux suivis d'un suffixe sont également des littéraux à virgule flottante.

 1F      // means the same thing as 1.0F

La signification d'un littéral décimal est le nombre à virgule flottante IEEE le plus proche du nombre réel mathématique de précision infinie désigné par la forme décimale à virgule flottante. Cette valeur conceptuelle est convertie en représentation à virgule flottante binaire IEEE en utilisant arrondi au plus proche . (La sémantique précise de la conversion décimale est spécifiée dans javadocs pour Double.valueOf(String) et Float.valueOf(String) , en gardant à l’esprit qu’il existe des différences dans les syntaxes de nombres.)

Formes décimales mises à l'échelle

Les formes décimales mises à l'échelle consistent en une décimale simple avec une partie exposant introduite par un E ou un e et suivie d'un entier signé. La partie exposant est une main courte pour multiplier la forme décimale par une puissance de dix, comme indiqué dans les exemples ci-dessous. Il existe également un suffixe facultatif permettant de distinguer les littéraux float et double . Voici quelques exemples:

 1.0E1    // this means 1.0 x 10^1 ... or 10.0 (double)
 1E-1D    // this means 1.0 x 10^(-1) ... or 0.1 (double)
 1.0e10f  // this means 1.0 x 10^(10) ... or 10000000000.0 (float)

La taille d'un littéral est limitée par la représentation ( float ou double ). C'est une erreur de compilation si le facteur d'échelle donne une valeur trop grande ou trop petite.

Formes hexadécimales

À partir de Java 6, il est possible d'exprimer des littéraux à virgule flottante en hexadécimal. La forme hexadécimale a une syntaxe analogue aux formes décimales simples et mises à l'échelle, avec les différences suivantes:

1. Chaque littéral hexadécimal à virgule flottante commence par un zéro ( 0 ), puis un x ou un X
2. Les chiffres du nombre (mais pas la partie exposant!) Incluent également les chiffres hexadécimaux a à f et leurs équivalents majuscules.
3. L'exposant est obligatoire et introduit par la lettre p (ou P ) au lieu de e ou E L'exposant représente un facteur d'échelle qui est une puissance de 2 au lieu d'une puissance de 10.

Voici quelques exemples:

0x0.0p0f    // this is zero expressed in hexadecimal form (`float`)
0xff.0p19   // this is 255.0 x 2^19 (`double`)

Conseil: comme la plupart des programmeurs Java ne connaissent pas les formulaires à virgule flottante hexadécimale, il est conseillé de les utiliser avec parcimonie.

Les dessous

À partir de Java 7, les traits de soulignement sont autorisés dans les chaînes de caractères des trois formes de littéral à virgule flottante. Cela s'applique également aux parties "exposant". Voir Utilisation des traits de soulignement pour améliorer la lisibilité .

Cas spéciaux

C'est une erreur de compilation si un littéral à virgule flottante dénote un nombre trop grand ou trop petit pour être représenté dans la représentation sélectionnée; c'est-à-dire si le nombre débordait à + INF ou -INF, ou à 0.0. Cependant, il est légal qu'un littéral représente un nombre dénormalisé non nul.

La syntaxe littérale à virgule flottante ne fournit pas de représentation littérale pour les valeurs spéciales IEEE 754 telles que les valeurs INF et NaN. Si vous devez les exprimer en code source, la méthode recommandée consiste à utiliser les constantes définies par java.lang.Float et java.lang.Double ; Par exemple Float.NaN , Float.NEGATIVE_INFINITY et Float.POSITIVE_INFINITY .

Littéraux de caractère

Littéraux de caractères constituent le moyen le plus pratique d'exprimer char valeurs dans le code source Java. Un littéral de caractère consiste en:

• Un caractère d'ouverture simple ( ' ).
• Une représentation d'un personnage. Cette représentation ne peut pas être un caractère simple ou un caractère de saut de ligne, mais il peut s'agir d'une séquence d'échappement introduite par un caractère barre oblique inverse ( \ ); voir Séquences d'échappement dans les littéraux .
• Un caractère de guillemet simple ( ' ).

Par exemple:

char a = 'a';
char doubleQuote = '"';
char singleQuote = '\'';

Un saut de ligne dans un littéral de caractère est une erreur de compilation:

char newline = '
// Compilation error in previous line
char newLine = '\n';  // Correct