Java Language
Literale

Einführung

Hexadezimal-, Oktal- und Binärliterale

Eine hexadecimal ist ein Wert in Basis-16. Es gibt 16 Ziffern, 0-9 und die Buchstaben AF (Fall spielt keine Rolle). AF für 10-16 .

Eine octal ist ein Wert in Basis-8 und verwendet die Ziffern 0-7 .

Eine binary Zahl ist ein Wert in Basis-2 und verwendet die Ziffern 0 und 1 .

Alle diese Zahlen ergeben den gleichen Wert 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

Beachten Sie, dass die binäre Literal-Syntax in Java 7 eingeführt wurde.

Das Oktal-Literal kann leicht eine Falle für semantische Fehler sein. Wenn Sie eine führende '0' für Ihre Dezimal-Literale definieren, erhalten Sie den falschen Wert:

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

Verwendung von Unterstreichungen zur Verbesserung der Lesbarkeit

Seit Java 7 ist es möglich, einen oder mehrere Unterstriche (_) zum Trennen von Zifferngruppen in einem primitiven Zahlenliteral zu verwenden, um deren Lesbarkeit zu verbessern.

Zum Beispiel sind diese beiden Erklärungen gleichwertig:

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

Dies kann wie folgt auf alle primitiven Zahlenliterale angewendet werden:

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;

Dies funktioniert auch mit Präfixen für binäre, oktale und hexadezimale Basen:

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

Es gibt ein paar Regeln für Unterstriche, die ihre Platzierung an folgenden Stellen verbieten :

• Am Anfang oder Ende einer Nummer (zB _123 oder 123_ sind nicht gültig)
• Angrenzend an einen Dezimalpunkt in einem Fließkommaliteral (zB 1._23 oder 1_.23 sind nicht gültig)
• Vor einem Suffix von F oder L (zB 1.23_F oder 9999999_L sind nicht gültig)
• In Positionen, an denen eine Zeichenfolge erwartet wird (zB 0_xFFFF ist nicht gültig)

Escape-Sequenzen in Literalen

String- und Zeichenliterale bieten einen Escape-Mechanismus, der Express-Zeichencodes zulässt, die ansonsten im Literal nicht zulässig wären. Eine Escape-Sequenz besteht aus einem Backslash-Zeichen ( \ ), gefolgt von einem oder mehreren anderen Zeichen. Die gleichen Sequenzen gelten für beide Zeichen- und Zeichenkettenliterale.

Der komplette Satz von Escape-Sequenzen lautet wie folgt:

Das <octal> im obigen Beispiel besteht aus einer, zwei oder drei Oktalstellen ('0' bis '7'), die eine Zahl zwischen 0 und 255 (dezimal) darstellen.

Beachten Sie, dass ein umgekehrter Schrägstrich gefolgt von einem anderen Zeichen eine ungültige Escape-Sequenz ist. Ungültige Escape-Sequenzen werden von der JLS als Kompilierungsfehler behandelt.

Referenz:

• JLS 3.10.6. Escape-Sequenzen für Zeichen- und Zeichenkettenliterale

Unicode entkommt

Zusätzlich zu den oben beschriebenen String- und Character-Escape-Sequenzen verfügt Java über einen allgemeineren Unicode-Escape-Mechanismus, wie in JLS 3.3 definiert . Unicode-Flucht Ein Unicode-Escape hat die folgende Syntax:

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

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

Ein Unicode-Escape- Code wird vom Java-Compiler einem Zeichen zugeordnet (streng genommen eine 16-Bit-Unicode- Codeeinheit ) und kann überall im Quellcode verwendet werden, wo das zugeordnete Zeichen gültig ist. Es wird häufig in Zeichen- und Zeichenkettenliteralen verwendet, wenn Sie ein Nicht-ASCII-Zeichen in einem Literal darstellen müssen.

Flucht in Regex

TBD

Dezimal-Integer-Literale

Integer-Literale bieten Werte, die verwendet werden können, wenn Sie eine byte , short , int , long oder char Instanz benötigen. (Dieses Beispiel konzentriert sich auf die einfachen Dezimalformen. In anderen Beispielen wird erläutert, wie Literale in Oktal-, Hexadezimal- und Binärform angegeben werden, und wie Unterstriche verwendet werden, um die Lesbarkeit zu verbessern.)

Gewöhnliche ganzzahlige Literale

Die einfachste und gebräuchlichste Form des Ganzzahl-Literal ist ein Dezimal-Ganzzahl-Literal. Zum Beispiel:

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

Sie müssen vorsichtig mit führenden Nullen sein. Eine führende Null bewirkt, dass ein Integer-Literal als Oktal und nicht als Dezimalzahl interpretiert wird.

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

Ganzzahlige Literale sind nicht signiert. Wenn Sie etwas wie -10 oder +10 , sind dies eigentlich Ausdrücke , die die unären - und unären + -Operatoren verwenden.

Der Bereich der ganzzahligen Literale dieser Form hat einen intrinsischen Typ von int und muss im Bereich von 0 bis 2 ³¹ oder 2 147 483 648 liegen.

Beachten Sie, dass 2 ³¹ um 1 größer als Integer.MAX_VALUE . Literale von 0 bis zu 2147483647 kann überall eingesetzt werden, aber es ist ein Übersetzungsfehler verwenden 2147483648 ohne vorherigen einstellige - Operator. (Mit anderen Worten, es ist für die Angabe des Wertes von Integer.MIN_VALUE .)

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

Lange ganzzahlige Literale

Literale vom Typ long werden durch Hinzufügen eines L Suffixes ausgedrückt. Zum Beispiel:

 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

Beachten Sie, dass der Unterschied zwischen int und long Literalen an anderen Stellen signifikant ist. Zum Beispiel

 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.

Referenz: JLS 3.10.1 - Integer Literals

Boolesche Literale

Boolesche Literale sind die einfachsten der Literale in der Programmiersprache Java. Die zwei möglichen boolean Werte werden durch die Literale true und false . Hierbei wird zwischen Groß- und Kleinschreibung unterschieden. Zum Beispiel:

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

String-Literale

String-Literale bieten die bequemste Möglichkeit, String-Werte im Java-Quellcode darzustellen. Ein String-Literal besteht aus:

• Ein doppeltes Anführungszeichen ( " ).
• Null oder mehrere andere Zeichen, die weder ein Anführungszeichen noch ein Zeilenumbruchzeichen sind. (Ein umgekehrter Schrägstrich ( \ ) ändert die Bedeutung nachfolgender Zeichen; siehe Escape-Sequenzen in Literalen .)
• Ein schließendes Anführungszeichen.

Zum Beispiel:

"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

Beachten Sie, dass sich ein einzelnes String-Literal möglicherweise nicht über mehrere Quellcodezeilen erstreckt. Es ist ein Kompilierungsfehler, wenn ein Zeilenumbruch (oder das Ende der Quelldatei) vor dem schließenden Anführungszeichen eines Literal auftritt. Zum Beispiel:

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

Lange Saiten

Wenn Sie eine Zeichenfolge benötigen, die zu lang ist, um in eine Zeile zu passen, können Sie sie normalerweise in mehrere Literale aufteilen und den Verkettungsoperator ( + ) verwenden, um die Teile zu verbinden. Zum Beispiel

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

Ein Ausdruck wie der oben genannte, der aus Zeichenkettenlitern und + erfüllt die Anforderungen, um ein konstanter Ausdruck zu sein . Das bedeutet, dass der Ausdruck vom Compiler ausgewertet und zur Laufzeit durch ein einzelnes String Objekt dargestellt wird.

Internierung von String-Literalen

Wenn Klassendatei Stringliterale enthält , durch die JVM geladen wird, werden die entsprechenden String sind Objekte , die von dem Laufzeitsystem interniert. Dies bedeutet, dass ein Zeichenfolgenliteral, das in mehreren Klassen verwendet wird, nicht mehr Speicherplatz beansprucht, als wenn es in einer Klasse verwendet würde.

Weitere Informationen zum Interning und zum String-Pool finden Sie im Beispiel zum String-Pool und zum Heap-Speicher im Thema Strings.

Das Null-Literal

Das Null-Literal (als null ) repräsentiert den einzigen Wert des Null-Typs. Hier sind einige Beispiele

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

    myMethod(null);

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

Der Nulltyp ist eher ungewöhnlich. Es hat keinen Namen und kann daher nicht in Java-Quellcode ausgedrückt werden. (Und es hat auch keine Laufzeitdarstellung.)

Der einzige Zweck des Null - Typs ist der Typ zu sein , null . Es ist mit allen Referenztypen zuweisungskompatibel und kann in einen beliebigen Referenztyp umgewandelt werden. (Im letzteren Fall erfordert die Besetzung keine Überprüfung des Laufzeittyps.)

Schließlich hat null die Eigenschaft, dass die null instanceof <SomeReferenceType> des Typs als false ausgewertet wird.

Fließkomma-Literale

Fließkomma-Literale liefern Werte, die verwendet werden können, wenn Sie eine float oder double benötigen. Es gibt drei Arten von Gleitkomma-Literalen.

• Einfache Dezimalformen
• Skalierte Dezimalformen
• Hexadezimalformen

(Die JLS-Syntaxregeln kombinieren die beiden Dezimalformen in einer einzigen Form. Wir behandeln sie zur Vereinfachung der Erklärung getrennt.)

Es gibt verschiedene Literaltypen für float und double Literale, die mit Suffixen ausgedrückt werden. Die verschiedenen Formen verwenden Buchstaben, um verschiedene Dinge auszudrücken. Diese Buchstaben unterscheiden nicht zwischen Groß- und Kleinschreibung.

Einfache Dezimalformen

Die einfachste Form des Gleitpunktliteral besteht aus einer oder mehreren Dezimalstellen und einem Dezimalpunkt ( . ) Und einem optionalen Suffix ( f , F , d oder D ). Mit dem optionalen Suffix können Sie angeben, dass das Literal ein float ( f oder F ) oder ein double ( d oder D ) ist. Der Standardwert (wenn kein Suffix angegeben ist) ist double .

Zum Beispiel

 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)

Dezimalstellen, gefolgt von einem Suffix, sind auch ein Fließkommaliteral.

 1F      // means the same thing as 1.0F

Die Bedeutung eines Dezimalliteral ist die IEEE-Gleitkommazahl, die der mathematischen Unendlichkeitsgenauigkeit "Real" am nächsten kommt , die mit der dezimalen Gleitkommaform bezeichnet wird. Dieser Wert wird konzeptuelle Darstellung umgewandelt binäre Gleitkomma IEEE Rund zum nächsten verwendet wird . (Die genaue Semantik der Dezimalkonvertierung wird in den Javadocs für Double.valueOf(String) und Float.valueOf(String) , wobei zu berücksichtigen ist, dass Unterschiede in der Zahlensyntax bestehen.)

Skalierte Dezimalformen

Skalierte Dezimalformen bestehen aus einfachen Dezimalzahlen mit einem durch ein E oder e eingeführten Exponententeil, gefolgt von einer vorzeichenbehafteten Ganzzahl. Der Exponent-Teil ist eine kurze Hand zum Multiplizieren der Dezimalform mit einer Zehnerpotenz, wie in den folgenden Beispielen gezeigt. Es gibt auch ein optionales Suffix zur Unterscheidung von float und double . Hier sind einige Beispiele:

 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)

Die Größe eines Literal wird durch die Darstellung ( float oder double ) begrenzt. Es ist ein Kompilierungsfehler, wenn der Skalierungsfaktor einen zu großen oder zu kleinen Wert ergibt.

Hexadezimalformen

Beginnend mit Java 6 ist es möglich, Fließkommaliter im Hexadezimalformat auszudrücken. Die Hexadezimalform hat eine analoge Syntax zu den einfachen und skalierten Dezimalformen mit den folgenden Unterschieden:

1. Jedes hexadezimale Fließkommaliteral beginnt mit einer Null ( 0 ) und dann einem x oder X
2. Die Ziffern der Zahl (aber nicht der Exponententeil!) Enthalten auch die hexadezimalen Ziffern a bis f und ihre Äquivalente in Großbuchstaben.
3. Der Exponent ist obligatorisch und wird durch den Buchstaben p (oder P ) anstelle von e oder E . Der Exponent stellt einen Skalierungsfaktor dar, der eine Potenz von 2 anstelle einer Potenz von 10 ist.

Hier sind einige Beispiele:

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

Hinweis: Da hexadezimale Fließkommaformulare für die meisten Java-Programmierer unbekannt sind, ist es ratsam, sie sparsam zu verwenden.

Unterstriche

Ab Java 7 sind in allen drei Formen des Fließkomma-Literales Unterstriche innerhalb der Ziffernfolgen zulässig. Dies gilt auch für die "Exponenten" -Teile. Siehe Unterstriche verwenden, um die Lesbarkeit zu verbessern .

Sonderfälle

Es ist ein Kompilierungsfehler, wenn ein Gleitkommaliteral eine Zahl angibt, die zu groß oder zu klein ist, um sie in der ausgewählten Darstellung darzustellen. dh wenn die Nummer zu + INF oder -INF überlaufen würde oder zu 0,0 unterlaufen würde. Es ist jedoch zulässig, dass ein Literal eine denormalisierte Zahl ungleich Null darstellt.

Die Fließkomma-Literal-Syntax bietet keine Literaldarstellungen für IEEE 754-Sonderwerte wie die INF- und NaN-Werte. Wenn Sie sie im Quellcode ausdrücken müssen, verwenden Sie die Konstanten java.lang.Float und java.lang.Double ; zB Float.NaN , Float.NEGATIVE_INFINITY und Float.POSITIVE_INFINITY .

Zeichenliterale

Zeichenliterale bieten die bequemste Möglichkeit, char im Java-Quellcode auszudrücken. Ein Zeichenliteral besteht aus:

• Ein anfängliches Anführungszeichen ( ' ).
• Eine Darstellung eines Charakters. Diese Darstellung kann kein einfaches Anführungszeichen oder Zeilenumbruchzeichen sein. Es kann sich jedoch um eine Escape-Sequenz handeln, die durch einen umgekehrten Schrägstrich ( \ ) eingeführt wird. Siehe Escape-Sequenzen in Literalen .
• Ein abschließendes einfaches Anführungszeichen ( ' ).

Zum Beispiel:

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

Ein Zeilenumbruch in einem Zeichenliteral ist ein Kompilierungsfehler:

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