Java Language
letterali

introduzione

Letterali esadecimali, ottali e binari

Un numero hexadecimal è un valore in base-16. Ci sono 16 cifre, 0-9 e le lettere AF (caso non importa). AF rappresenta 10-16 .

Un numero octal è un valore in base-8 e utilizza le cifre 0-7 .

Un numero binary è un valore in base-2 e utilizza le cifre 0 e 1 .

Tutti questi numeri hanno lo stesso valore, 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

Si noti che la sintassi binaria letterale è stata introdotta in Java 7.

Il letterale ottale può facilmente essere una trappola per errori semantici. Se definisci uno '0' ai tuoi valori decimali, otterrai il valore errato:

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

Usando il trattino basso per migliorare la leggibilità

Da Java 7 è stato possibile utilizzare uno o più caratteri di sottolineatura (_) per separare gruppi di cifre in un numero letterale primitivo per migliorarne la leggibilità.

Ad esempio, queste due dichiarazioni sono equivalenti:

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

Questo può essere applicato a tutti i numeri letterali primitivi come mostrato di seguito:

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;

Questo funziona anche usando i prefissi per basi binarie, ottali ed esadecimali:

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

Ci sono alcune regole sui caratteri di sottolineatura che vietano il loro posizionamento nei seguenti luoghi:

• All'inizio o alla fine di un numero (ad es. _123 o 123_ non sono validi)
• Adiacente a un punto decimale in un letterale in virgola mobile (ad es. 1._23 o 1_.23 non sono validi)
• Prima di un suffisso F o L (ad es. 1.23_F o 9999999_L non sono validi)
• Nelle posizioni in cui è prevista una stringa di cifre (ad es. 0_xFFFF non è valido)

Fuga di sequenze in letterali

Stringhe e caratteri letterali forniscono un meccanismo di escape che consente di esprimere codici di caratteri che altrimenti non sarebbero consentiti nel letterale. Una sequenza di escape consiste in un carattere barra rovesciata ( \ ) seguito da uno o più altri caratteri. Le stesse sequenze sono valide in entrambi i caratteri e in stringhe letterali.

L'insieme completo di sequenze di escape è il seguente:

Il <octal> in quanto sopra è costituito da una, due o tre cifre ottali (da '0' a '7') che rappresentano un numero compreso tra 0 e 255 (decimale).

Si noti che una barra rovesciata seguita da qualsiasi altro carattere è una sequenza di escape non valida. Le sequenze di escape non valide vengono trattate come errori di compilazione dal JLS.

Riferimento:

• JLS 3.10.6. Sequenze di escape per caratteri e stringhe letterali

Escape Unicode

Oltre alle sequenze di escape di stringhe e caratteri descritte sopra, Java ha un meccanismo di escape di Unicode più generale, come definito in JLS 3.3. Unicode Escapes . Una escape Unicode ha la seguente sintassi:

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

dove <hex-digit> è uno tra '0' , '1' , '2' , '3' , '4' , '5' , '6' , '7' , '8' , '9' , 'a' , 'b' , 'c' , 'd' , 'e' , 'f' , 'A' , 'B' , 'C' , 'D' , 'E' , 'F' .

Un'uscita Unicode viene mappata dal compilatore Java a un carattere (in senso stretto un'unità di codice Unicode a 16 bit) e può essere utilizzata ovunque nel codice sorgente in cui il carattere mappato è valido. È comunemente usato in caratteri e stringhe letterali quando è necessario rappresentare un carattere non ASCII in un letterale.

Escaping in regex

TBD

Letterali decimali interi

I valori letterali interi forniscono valori che possono essere utilizzati laddove è necessaria un'istanza byte , short , int , long o char . (Questo esempio si concentra sulle semplici forme decimali.Altri esempi spiegano come eseguire letterali in ottale, esadecimale e binario e l'uso di caratteri di sottolineatura per migliorare la leggibilità.)

Letterali interi ordinari

La forma più semplice e più comune di valori letterali interi è un valore letterale intero decimale. Per esempio:

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

Devi stare attento con gli zeri iniziali. Uno zero iniziale causa un'interpretazione letterale integer da interpretare come ottale non decimale.

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

I valori letterali interi non sono firmati. Se vedete qualcosa di simile a -10 o +10 , queste sono in realtà espressioni utilizzando i unari - e unari + operatori.

L'intervallo di valori letterali interi di questo modulo ha un tipo intrinseco di int e deve rientrare nell'intervallo compreso tra zero e 2 ³¹ o 2.147.483.648.

Notare che 2 ³¹ è 1 maggiore di Integer.MAX_VALUE . Letterali da 0 fino alla 2147483647 può essere utilizzato ovunque, ma è un errore di compilazione di utilizzare 2147483648 senza un unario precedente - operatore. (In altre parole, è riservato per esprimere il valore di Integer.MIN_VALUE .)

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

Letterali interi lunghi

I letterali di tipo long vengono espressi aggiungendo un suffisso L Per esempio:

 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

Nota che la distinzione tra int e letterali long è significativa in altri posti. Per esempio

 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.

Riferimento: JLS 3.10.1 - Integer Literals

Letterali booleani

I letterali booleani sono il più semplice dei letterali nel linguaggio di programmazione Java. I due possibili valori boolean sono rappresentati dai letterali true e false . Questi sono case-sensitive. Per esempio:

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

Stringhe letterali

Le stringhe letterali forniscono il modo più conveniente per rappresentare i valori stringa nel codice sorgente Java. Una stringa letterale consiste di:

• Un carattere di apertura doppia citazione ( " ).
• Zero o più altri caratteri che non sono né una virgoletta o un carattere di interruzione di riga. (Un carattere barra rovesciata ( \ ) altera il significato dei caratteri successivi, vedi Escape sequenze in letterali .)
• Un carattere di doppia citazione di chiusura.

Per esempio:

"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

Si noti che una singola stringa letterale non può estendersi su più righe di codice sorgente. Si tratta di un errore di compilazione per un'interruzione di riga (o la fine del file di origine) che si verifica prima della doppia virgola di chiusura di un letterale. Per esempio:

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

Corde lunghe

Se hai bisogno di una stringa troppo lunga per adattarsi a una linea, il modo convenzionale per esprimerlo è dividerla in più letterali e utilizzare l'operatore di concatenazione ( + ) per unire i pezzi. Per esempio

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

Un'espressione come la precedente consistente in string letterali e + soddisfa i requisiti per essere un'espressione costante . Ciò significa che l'espressione verrà valutata dal compilatore e rappresentata in fase di esecuzione da un singolo oggetto String .

Interning di stringhe letterali

Quando il file di classe contenente stringhe letterali viene caricato da JVM, gli oggetti String corrispondenti vengono internati dal sistema di runtime. Ciò significa che una stringa letterale utilizzata in più classi non occupa più spazio rispetto a se fosse utilizzata in una classe.

Per ulteriori informazioni sull'internamento e sul pool di stringhe, fare riferimento al pool di stringhe e all'heap storage esempio nell'argomento Strings.

Il letterale Null

Il valore letterale Null (scritto come null ) rappresenta l'unico valore del tipo null. Ecco alcuni esempi

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

    myMethod(null);

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

Il tipo null è piuttosto inusuale. Non ha nome, quindi non puoi esprimerlo nel codice sorgente Java. (E non ha nemmeno una rappresentazione runtime.)

L'unico scopo del tipo nullo è di essere il tipo di null . È un'assegnazione compatibile con tutti i tipi di riferimento e può essere digitata per qualsiasi tipo di riferimento. (In quest'ultimo caso, il cast non comporta un controllo del tipo di runtime.)

Infine, null ha la proprietà che null instanceof <SomeReferenceType> valuterà in false , indipendentemente dal tipo.

Letterali in virgola mobile

I valori letterali in virgola mobile forniscono valori che possono essere utilizzati laddove è necessario un float o una double istanza. Esistono tre tipi di letterale in virgola mobile.

• Semplici forme decimali
• Forme decimali ridimensionate
• Forme esadecimali

(Le regole di sintassi JLS combinano le due forme decimali in un unico modulo. Li trattiamo separatamente per facilitare la spiegazione.)

Esistono tipi letterali distinti per float e double literals, espressi usando i suffissi. Le varie forme usano le lettere per esprimere cose diverse. Queste lettere non fanno distinzione tra maiuscole e minuscole.

Semplici forme decimali

La forma più semplice di letterale in virgola mobile consiste di una o più cifre decimali e un punto decimale ( . ) E un suffisso opzionale ( f , F , d o D ). Il suffisso opzionale consente di specificare che il valore letterale è un valore float ( f o F ) o double ( d o D ). L'impostazione predefinita (quando non viene specificato alcun suffisso) è double .

Per esempio

 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)

Infatti, le cifre decimali seguite da un suffisso sono anche letterali in virgola mobile.

 1F      // means the same thing as 1.0F

Il significato di un valore letterale decimale è il numero in virgola mobile IEEE più vicino al numero reale matematico di precisione infinita indicato dalla forma decimale in virgola mobile. Questo valore concettuale viene convertito in rappresentazione in virgola mobile binaria IEEE usando round to nearest . (La semantica precisa della conversione decimale è specificata in Double.valueOf(String) per Double.valueOf(String) e Float.valueOf(String) , tenendo presente che ci sono differenze nelle sintassi dei numeri.)

Forme decimali ridimensionate

Le forme decimali in scala consistono in semplici decimali con una parte esponenziale introdotta da una E o e , seguita da un intero con segno. La parte esponente è una mano corta per moltiplicare la forma decimale di un potere di dieci, come mostrato negli esempi qui sotto. Esiste anche un suffisso opzionale per distinguere i letterali float e double . Ecco alcuni esempi:

 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 dimensione di un letterale è limitata dalla rappresentazione ( float o double ). È un errore di compilazione se il fattore di scala genera un valore troppo grande o troppo piccolo.

Forme esadecimali

A partire da Java 6, è possibile esprimere valori letterali in virgola mobile in formato esadecimale. La forma esadecimale ha una sintassi analoga alle forme decimali semplici e in scala con le seguenti differenze:

1. Ogni letterale in virgola mobile esadecimale inizia con uno zero ( 0 ) e quindi con una x o una X
2. Le cifre del numero (ma non la parte esponenziale!) Includono anche le cifre esadecimali da a a f e i loro equivalenti maiuscoli.
3. L'esponente è obbligatorio e viene introdotto dalla lettera p (o P ) invece di una e o E L'esponente rappresenta un fattore di scala che è una potenza di 2 invece di una potenza di 10.

Ecco alcuni esempi:

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

Consiglio: poiché le forme esadecimali a virgola mobile non sono familiari alla maggior parte dei programmatori Java, è consigliabile utilizzarle con parsimonia.

sottolineatura

A partire da Java 7, i caratteri di sottolineatura sono consentiti all'interno delle stringhe di cifre in tutte e tre le forme di letterale in virgola mobile. Questo vale anche per le parti "esponenti". Vedi Usare caratteri di sottolineatura per migliorare la leggibilità .

Casi speciali

È un errore di compilazione se un letterale in virgola mobile denota un numero troppo grande o troppo piccolo per rappresentare nella rappresentazione selezionata; vale a dire se il numero sarebbe traboccare a + INF o -INF, o underflow a 0.0. Tuttavia, è legale per un valore letterale rappresentare un numero denormalizzato diverso da zero.

La sintassi letterale in virgola mobile non fornisce rappresentazioni letterali per valori speciali IEEE 754 come i valori INF e NaN. Se è necessario esprimerli nel codice sorgente, il metodo consigliato è utilizzare le costanti definite da java.lang.Float e java.lang.Double ; ad esempio, Float.NaN , Float.NEGATIVE_INFINITY e Float.POSITIVE_INFINITY .

Caratteri letterali

I caratteri letterali forniscono il modo più conveniente per esprimere valori di char nel codice sorgente Java. Un carattere letterale consiste di:

• Un carattere di apertura singola ( ' ).
• Una rappresentazione di un personaggio. Questa rappresentazione non può essere una virgoletta singola o un carattere di interruzione di riga, ma può essere una sequenza di escape introdotta da un carattere barra rovesciata ( \ ); vedi Escape sequenze in letterali .
• Un carattere di chiusura singola ( ' ) di chiusura.

Per esempio:

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

Un'interruzione di riga in un carattere letterale è un errore di compilazione:

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