Java Language
literals

Invoering

Hexadecimale, Octale en Binaire literalen

Een hexadecimal getal is een waarde in base-16. Er zijn 16 cijfers, 0-9 en de letters AF (hoofdletter maakt niet uit). AF staat voor 10-16 .

Een octal getal is een waarde in basis-8 en gebruikt de cijfers 0-7 .

Een binary getal is een waarde in base-2 en gebruikt de cijfers 0 en 1 .

Al deze getallen hebben dezelfde waarde, 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

Merk op dat binaire letterlijke syntaxis is geïntroduceerd in Java 7.

Het letterlijke octale kan gemakkelijk een val zijn voor semantische fouten. Als u een voorloop '0' definieert voor uw decimale letterlijke waarden, krijgt u de verkeerde waarde:

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

Onderstrepingsteken gebruiken om de leesbaarheid te verbeteren

Sinds Java 7 is het mogelijk om een of meer onderstrepingstekens (_) te gebruiken voor het scheiden van groepen cijfers in een primitief letterlijk getal om hun leesbaarheid te verbeteren.

Deze twee verklaringen zijn bijvoorbeeld gelijkwaardig:

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

Dit kan worden toegepast op alle primitieve aantal literals zoals hieronder getoond:

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;

Dit werkt ook met voorvoegsels voor binaire, octale en hexadecimale basissen:

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

Er zijn enkele regels over onderstrepingstekens die plaatsing op de volgende plaatsen verbieden :

• Aan het begin of einde van een nummer (bijv. _123 of 123_ zijn niet geldig)
• Grenzend aan een decimaal punt in een letterlijk drijvend punt (bijv. 1._23 of 1_.23 zijn niet geldig)
• Voorafgaand aan een F- of L-achtervoegsel (bijvoorbeeld 1.23_F of 9999999_L zijn niet geldig)
• Op posities waar een reeks cijfers wordt verwacht (bijv. 0_xFFFF is niet geldig)

Ontsnap sequenties in letterlijke

Tekenreeks- en tekenliteralen bieden een ontsnappingsmechanisme dat uitdrukkelijke tekencodes mogelijk maakt die anders in het letterlijke niet zouden zijn toegestaan. Een escape-reeks bestaat uit een backslash-teken ( \ ) gevolgd door een of meer andere tekens. Dezelfde reeksen zijn geldig in beide lettertekens en tekenreeks.

De complete set ontsnappingsreeksen is als volgt:

Het <octal> in het bovenstaande bestaat uit een, twee of drie octale cijfers ('0' tot '7') die een getal tussen 0 en 255 (decimaal) vertegenwoordigen.

Merk op dat een backslash gevolgd door een ander karakter een ongeldige escape-reeks is. Ongeldige escape-reeksen worden door de JLS als compilatiefouten behandeld.

Referentie:

• JLS 3.10.6. Escape-reeksen voor letter- en tekenreeksliteralen

Unicode ontsnapt

Naast de hierboven beschreven tekenreeks- en teken-escape-reeksen, heeft Java een meer algemeen Unicode-ontsnappingsmechanisme, zoals gedefinieerd in JLS 3.3. Unicode ontsnapt . Een Unicode-escape heeft de volgende syntaxis:

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

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

Een Unicode-escape wordt door de Java-compiler toegewezen aan een teken (strikt genomen een 16-bits Unicode- code-eenheid ) en kan overal in de broncode worden gebruikt waar het toegewezen teken geldig is. Het wordt vaak gebruikt in letterlijke tekens en tekenreeksen wanneer u een niet-ASCII-teken in een letterlijke vorm moet vertegenwoordigen.

Ontsnappen in regexen

TBD

Decimale gehele getallen

Integer literals bieden waarden die kunnen worden gebruikt waar u een byte , short , int , long of char exemplaar nodig hebt. (Dit voorbeeld richt zich op de eenvoudige decimale vormen. Andere voorbeelden leggen uit hoe letterlijke tekens in octaal, hexadecimaal en binair, en het gebruik van onderstrepingstekens om de leesbaarheid te verbeteren.)

Gewone letterlijke getallen

De eenvoudigste en meest voorkomende vorm van letterlijk gehele getallen is een decimale letterlijke geheel getal. Bijvoorbeeld:

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

Je moet voorzichtig zijn met voorloopnullen. Een voorloopnul zorgt ervoor dat een geheel getal letterlijk wordt geïnterpreteerd als octaal en niet als decimaal.

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

Letterlijke getallen zonder teken. Als u zoiets als -10 of +10 , zijn dit eigenlijk uitdrukkingen die de operatoren unary - en unary + gebruiken.

Het bereik van gehele getallen van deze vorm heeft een intrinsiek type int en moet binnen het bereik nul tot 2 ³¹ of 2.147.483.648 vallen.

Merk op dat 2 ³¹ 1 groter is dan Integer.MAX_VALUE . Letterlijke van 0 tot 2147483647 overal te gebruiken, maar het is een compilatiefout gebruik 2147483648 zonder voorafgaande unaire - operator. (Met andere woorden, het is gereserveerd voor het uitdrukken van de waarde van Integer.MIN_VALUE .)

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

Lange letterlijke getallen

Letterlijke type long expressie worden gebracht door toevoeging van een L achtervoegsel. Bijvoorbeeld:

 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

Merk op dat het onderscheid tussen int en long letterlijke waarden op andere plaatsen significant is. Bijvoorbeeld

 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.

Referentie: JLS 3.10.1 - Integer literals

Booleaanse literals

Booleaanse literalen zijn de eenvoudigste van de letterlijke in de programmeertaal Java. De twee mogelijke boolean waarden worden voorgesteld door de letterlijke true en false . Deze zijn hoofdlettergevoelig. Bijvoorbeeld:

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

String literals

Stringliterals bieden de handigste manier om stringwaarden in Java-broncode weer te geven. Een letterlijke string bestaat uit:

• Een openingsteken met dubbele aanhalingstekens ( " ).
• Nul of meer andere tekens die geen dubbele aanhalingstekens of regeleindetekens zijn. (Een backslash ( \ ) -teken wijzigt de betekenis van volgende tekens; zie Escape-reeksen in letterlijke tekens.)
• Een afsluitend dubbel aanhalingsteken.

Bijvoorbeeld:

"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

Merk op dat een letterlijke string niet meerdere broncoderegels kan omvatten. Het is een compilatiefout voor een regeleinde (of het einde van het bronbestand) vóór het afsluitende dubbele citaat van een letterlijke letter. Bijvoorbeeld:

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

Lange snaren

Als je een string nodig hebt die te lang is om op een lijn te passen, is de conventionele manier om het uit te drukken het in meerdere letterlijke delen op te splitsen en de samenvoegingsoperator ( + ) te gebruiken om de stukken samen te voegen. Bijvoorbeeld

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

Een uitdrukking zoals de bovenstaande, bestaande uit tekenreeksliteralen en + voldoet aan de vereisten om een constante uitdrukking te zijn . Dat betekent dat de uitdrukking door de compiler wordt geëvalueerd en tijdens runtime wordt voorgesteld door een enkel String object.

Interning van stringliterals

Wanneer het klassebestand met stringliterals wordt geladen door de JVM, worden de overeenkomstige String objecten geïnterneerd door het runtime-systeem. Dit betekent dat een letterlijke tekenreeks die in meerdere klassen wordt gebruikt, niet meer ruimte inneemt dan wanneer deze in één klasse zou worden gebruikt.

Raadpleeg voor meer informatie over interning en de stringpool het voorbeeld Stringpool en heap-opslag in het onderwerp Strings.

De letterlijke nul

De letterlijke null (geschreven als null ) vertegenwoordigt de enige waarde van het nultype. Hier zijn enkele voorbeelden

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

    myMethod(null);

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

Het nultype is nogal ongebruikelijk. Het heeft geen naam, dus u kunt het niet in Java-broncode uitdrukken. (En het heeft ook geen runtime-weergave.)

Het enige doel van het nultype is het type null . Het is toewijzingscompatibel met alle referentietypen en kan naar elk referentietype worden gegoten. (In het laatste geval houdt de cast geen runtime-typecontrole in.)

Ten slotte heeft null de eigenschap dat null instanceof <SomeReferenceType> wordt geëvalueerd als false , ongeacht het type.

Drijvende-komma letterlijk

Drijvende-komma-letterlijke waarden bieden waarden die kunnen worden gebruikt waar u een float of double instantie nodig hebt. Er zijn drie soorten letterlijke zwevende punten.

• Eenvoudige decimale vormen
• Geschaalde decimale vormen
• Hexadecimale vormen

(De JLS-syntaxisregels combineren de twee decimale vormen in één vorm. We behandelen ze afzonderlijk voor het gemak van uitleg.)

Er zijn verschillende lettertypen voor float en double literals, uitgedrukt met achtervoegsels. De verschillende vormen gebruiken letters om verschillende dingen uit te drukken. Deze letters zijn niet hoofdlettergevoelig.

Eenvoudige decimale vormen

De eenvoudigste vorm van letterlijk drijvende komma bestaat uit een of meer decimale cijfers en een decimale punt ( . ) En een optioneel achtervoegsel ( f , F , d of D ). Met het optionele achtervoegsel kunt u opgeven dat de letterlijke waarde een float ( f of F ) of double ( d of D ) is. De standaardwaarde (wanneer geen achtervoegsel is opgegeven) is double .

Bijvoorbeeld

 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)

In feite zijn decimale cijfers gevolgd door een achtervoegsel ook letterlijk een drijvend punt.

 1F      // means the same thing as 1.0F

De betekenis van een decimaal letterlijk is het IEEE drijvende-kommagetal dat het dichtst in de buurt komt van het oneindige nauwkeurige wiskundige reële getal dat wordt aangegeven door de decimale drijvende komma-vorm. Deze conceptuele waarde wordt geconverteerd naar IEEE binaire drijvende komma-weergave met behulp van rond naar dichtstbijzijnde . (De precieze semantiek van de decimale conversie wordt opgegeven in de javadocs voor Double.valueOf(String) en Float.valueOf(String) , rekening houdend met het feit dat er verschillen zijn in de syntaxis van het aantal.)

Geschaalde decimale vormen

Geschaalde decimale vormen bestaan uit eenvoudige decimalen met een exponentdeel dat wordt geïntroduceerd door een E of e en wordt gevolgd door een geheel getal met teken. Het exponentgedeelte is een korte hand voor het vermenigvuldigen van de decimale vorm met een macht van tien, zoals weergegeven in de onderstaande voorbeelden. Er is ook een optioneel achtervoegsel om float en double literals te onderscheiden. Hier zijn enkele voorbeelden:

 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)

De grootte van een letterlijke wordt beperkt door de weergave ( float of double ). Het is een compilatiefout als de schaalfactor resulteert in een waarde die te groot of te klein is.

Hexadecimale vormen

Beginnend met Java 6, is het mogelijk om drijvende komma letterlijk uit te drukken in hexadecimaal. De hexadecimale vorm heeft een analoge syntaxis van de eenvoudige en geschaalde decimale vormen met de volgende verschillen:

1. Elk letterlijk hexadecimaal drijvend punt begint met een nul ( 0 ) en vervolgens een x of X
2. De cijfers van het nummer (maar niet het exponentgedeelte!) Omvatten ook de hexadecimale cijfers a tot en met f en hun hoofdequivalenten.
3. De exponent is verplicht en wordt geïntroduceerd door de letter p (of P ) in plaats van een e of E De exponent vertegenwoordigt een schaalfactor die een macht van 2 is in plaats van een macht van 10.

Hier zijn enkele voorbeelden:

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

Advies: aangezien hexadecimale drijvende-kommavormen niet bekend zijn bij de meeste Java-programmeurs, is het raadzaam ze spaarzaam te gebruiken.

underscores

Vanaf Java 7 zijn onderstrepingstekens toegestaan binnen de cijferreeksen in alle drie de vormen van letterlijk drijvende komma. Dit geldt ook voor de "exponent" -onderdelen. Zie Onderstrepingstekens gebruiken om de leesbaarheid te verbeteren .

Speciale gevallen

Het is een compilatiefout als een letterlijk drijvend punt een getal aangeeft dat te groot of te klein is om in de geselecteerde weergave weer te geven; dat wil zeggen als het nummer zou overstromen naar + INF of -INF, of zou overstromen naar 0.0. Het is echter legaal dat een letterlijke waarde een niet-nul gedenormaliseerd getal vertegenwoordigt.

De letterlijke syntaxis van het zwevende punt biedt geen letterlijke weergaven voor speciale IEEE 754-waarden zoals de INF- en NaN-waarden. Als u ze in broncode moet uitdrukken, is de aanbevolen manier om de constanten te gebruiken die zijn gedefinieerd door java.lang.Float en java.lang.Double ; bijv. Float.NaN , Float.NEGATIVE_INFINITY en Float.POSITIVE_INFINITY .

Letterlijke lettertekens

Lettertypen van tekens bieden de handigste manier om char waarden in Java-broncode uit te drukken. Een letterlijke letter bestaat uit:

• Een openingsteken ( ' ) met enkele aanhalingstekens.
• Een weergave van een personage. Deze weergave kan geen enkel aanhalingsteken of een regeleinde zijn, maar het kan een escape-reeks zijn die wordt geïntroduceerd door een backslash ( \ ); zie Escape-reeksen in literals .
• Een afsluitend enkele aanhalingsteken ( ' ).

Bijvoorbeeld:

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

Een regeleinde in een letterlijke letter is een compilatiefout:

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