Java Language
litteraler

Introduktion

Hexadecimala, octala och binära bokstäver

Ett hexadecimal är ett värde i bas-16. Det finns 16 siffror, 0-9 och bokstäverna AF (fall spelar ingen roll). AF representerar 10-16 .

Ett octal är ett värde i bas-8 och använder siffrorna 0-7 .

Ett binary tal är ett värde i bas-2 och använder siffrorna 0 och 1 .

Alla dessa siffror ger samma värde, 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

Observera att binär bokstavlig syntax introducerades i Java 7.

Den octal literal kan lätt vara en fälla för semantiska fel. Om du definierar en ledande '0' till dina decimallitteraturer får du fel värde:

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

Använda understruk för att förbättra läsbarheten

Sedan Java 7 har det varit möjligt att använda en eller flera understreck (_) för att separera grupper av siffror i ett primitivt antal bokstavligen för att förbättra deras läsbarhet.

Till exempel är dessa två deklarationer likvärdiga:

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

Detta kan tillämpas på alla primitiva antal bokstäver som visas nedan:

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;

Detta fungerar också med prefix för binära, oktala och hexadecimala baser:

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

Det finns några regler om understreck som förbjuder deras placering på följande platser:

• I början eller slutet av ett nummer (t.ex. _123 eller 123_ är inte giltiga)
• Intill en decimalpunkt i en flytande punkt bokstavlig (t.ex. 1._23 eller 1_.23 är inte giltiga)
• Innan ett F- eller L-suffix (t.ex. 1.23_F eller 9999999_L är inte giltiga)
• I positioner där en rad siffror förväntas (t.ex. 0_xFFFF är inte giltigt)

Escape-sekvenser i bokstäver

Sträng- och karaktärsbokstäver tillhandahåller en flyktmekanism som tillåter uttryckliga karaktärskoder som annars inte skulle tillåtas i det bokstavliga. En flyktningssekvens består av ett backslashtecken ( \ ) följt av ytterligare ett antal andra tecken. Samma sekvenser är giltiga i båda tecknen och i strängbokstäver.

Den kompletta uppsättningen av escape-sekvenser är som följer:

<octal> i ovanstående består av en, två eller tre oktala siffror ('0' till '7') som representerar ett tal mellan 0 och 255 (decimal).

Observera att ett bakslag som följs av något annat tecken är en ogiltig flyktningsföljd. Ogiltiga flykt-sekvenser behandlas som kompilationsfel av JLS.

Referens:

• JLS 3.10.6. Escape Sekvenser för karaktär och streng litteraler

Unicode flyr

Förutom sträng- och karaktärsekvenssekvenserna som beskrivs ovan, har Java en mer generell Unicode-undkommande mekanism, enligt definitionen i JLS 3.3. Unicode flyr . En Unicode-flykt har följande syntax:

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

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

En Unicode-flykt mappas av Java-kompilatorn till ett tecken (strikt sett en 16-bitars Unicode- kodenhet ) och kan användas var som helst i källkoden där det mappade tecknet är giltigt. Det används vanligtvis i tecken- och strängbokstäver när du behöver representera ett icke-ASCII-tecken i en bokstavlig.

Rymmer i regexer

TBD

Decimal heltal bokstäver

Heltalsbokstäver ger värden som kan användas där du behöver en byte , short , int , long eller char instans. (Det här exemplet fokuserar på de enkla decimalformerna. Andra exempel förklarar hur man ska bokstäver i octal, hexadecimal och binär, och användningen av understreck för att förbättra läsbarheten.)

Vanliga heltalslitteraler

Den enklaste och vanligaste formen av heltal bokstavligen är en decimal heltal bokstavlig. Till exempel:

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

Du måste vara försiktig med ledande nollor. En ledande noll gör att ett heltal bokstavligt tolkas som oktalt och inte decimal.

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

Heltalsbokstäver är osignerade. Om du ser något som -10 eller +10 , är det faktiskt uttryck med operatörer unary - och unary + .

Räckvidden för heltalslitteraler i denna form har en egen typ av int och måste falla inom området noll till 2 ³¹ eller 2 147 473 648.

Observera att 2 ³¹ är 1 större än Integer.MAX_VALUE . Bokstäver från 0 till 2147483647 kan användas var som helst, men det är ett sammanställningsfel att använda 2147483648 utan föregående unary - operatör. (Med andra ord är det reserverat för att uttrycka värdet för Integer.MIN_VALUE .)

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

Långa heltalslitteraler

Bokstäver av typ av long uttrycks genom att lägga till en L suffix. Till exempel:

 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

Observera att skillnaden mellan int och long bokstäver är betydande på andra platser. Till exempel

 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.

Referens: JLS 3.10.1 - Heltaliga bokstäver

Booleska bokstäver

Booleska bokstäver är de enklaste av bokstäverna i programmeringsspråket Java. De två möjliga boolean värdena representeras av bokstäverna true och false . Dessa är skiftlägeskänsliga. Till exempel:

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

Strängbokstäver

Strängbokstäver är det bekvämaste sättet att representera strängvärden i Java-källkod. En strängbokstav består av:

• En öppnande dubbelcitationstecken ( " ).
• Noll eller fler andra tecken som varken är ett dubbelcitationstecken eller ett linjebrytande tecken. (En backslash ( \ ) -tecken förändrar innebörden av efterföljande tecken; se Escape-sekvenser i bokstäver .)
• En avslutande karaktär med dubbla offertar.

Till exempel:

"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

Observera att en enda strängbokstav inte kanske sträcker sig över flera källkodslinjer. Det är ett sammanställningsfel för en radbrytning (eller slutet på källfilen) som inträffar före en bokstavs slutande dubbelcitationstecken. Till exempel:

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

Långa strängar

Om du behöver en sträng som är för lång för att passa på en linje är det konventionella sättet att uttrycka det att dela upp det i flera bokstäver och använda kopplingsoperatören ( + ) för att gå med i bitarna. Till exempel

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

Ett uttryck som ovan bestående av strängbokstäver och + uppfyller kraven för att vara ett konstant uttryck . Det betyder att uttrycket kommer att utvärderas av kompilatorn och representeras vid körning av ett enda String .

Interning av strängbokstäver

När klassfilen innehållande stränglitteraler belastas av JVM, de motsvarande String är föremål interned av körningssystemet. Detta innebär att en strängbokstav som används i flera klasser inte tar mer plats än om den användes i en klass.

För mer information om interning och strängpoolen, se String pool och heap-lagringsexempel i strängar ämnet.

Den noll bokstavliga

Noll-bokstäverna (skrivna som null ) representerar det enda värdet på nolltypen. Här är några exempel

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

    myMethod(null);

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

Nolltypen är ganska ovanlig. Det har inget namn, så du kan inte uttrycka det i Java-källkod. (Och det har inte heller någon runtime-representation.)

Det enda syftet med nolltypen är att vara null . Det är tilldelningskompatibelt med alla referenstyper och kan typgjutas till valfri referenstyp. (I det senare fallet medför inte rollspelaren en runtime-kontroll.)

Slutligen har null den egenskap som null instanceof <SomeReferenceType> kommer att utvärdera till false , oavsett vilken typ det är.

Flytande punkt bokstäver

Flytande punktbokstäver ger värden som kan användas där du behöver en float eller double instans. Det finns tre typer av flytande punkt bokstavliga.

• Enkla decimalformer
• Skalade decimalformer
• Hexadecimala former

(JLS-syntaxreglerna kombinerar de två decimalformerna till en enda form. Vi behandlar dem separat för att förenkla förklaringen.)

Det finns distinkta bokstavliga typer för float och double bokstäver, uttryckta med suffix. De olika formerna använder bokstäver för att uttrycka olika saker. Dessa brev är okänsliga för versaler.

Enkla decimalformer

Den enklaste formen av flytande punkt bokstavlig består av en eller flera decimaler och en decimalpunkt ( . ) Och ett valfritt suffix ( f , F , d eller D ). Det valfria tillägget låter dig ange att bokstäverna är ett float ( f eller F ) eller double ( d eller D ) värde. Standardvärdet (när inget suffix anges) är double .

Till exempel

 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)

I själva verket är decimalsiffror följt av ett suffix också en flytande punkt bokstavlig.

 1F      // means the same thing as 1.0F

Betydelsen av en decimalbokstav är IEEE-flytpunktsnumret som är närmast den oändliga matematiska precisa reella tal som betecknas med den decimala flytpunktsformen. Detta konceptuella värde konverteras till IEEE binär flytande punktrepresentation med hjälp av runda till närmaste . (Den exakta semantiken för decimalkonvertering anges i javadokorna för Double.valueOf(String) och Float.valueOf(String) , med tanke på att det finns skillnader i antalet syntaxer.)

Skalade decimalformer

Skalade decimalformer består av enkla decimaler med en exponentdel introducerad av en E eller e , följt av ett signerat heltal. Exponentdelen är en kort hand för att multiplicera decimalformen med en effekt på tio, som visas i exemplen nedan. Det finns också ett valfritt suffix för att särskilja float och double literaler. Här är några exempel:

 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)

Storleken på en bokstavlig begränsas av representationen ( float eller double ). Det är ett sammanställningsfel om skalfaktorn resulterar i ett värde som är för stort eller för litet.

Hexadecimala former

Från och med Java 6 är det möjligt att uttrycka flytande punktlitteraler i hexadecimala. Den hexadecimala formen har en analog syntax till de enkla och skalade decimalformerna med följande skillnader:

1. Varje hexadecimal flytande punktbokstav börjar med en noll ( 0 ) och sedan en x eller X
2. Siffrorna i siffran (men inte exponentdelen!) Inkluderar också de hexadecimala siffrorna a till f och deras stora ekvivalenter.
3. Exponenten är obligatorisk och introduceras av bokstaven p (eller P ) istället för en e eller E Exponenten representerar en skalfaktor som är en effekt på 2 istället för en effekt på 10.

Här är några exempel:

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

Råd: Eftersom hexadecimala flytpunktsformer är okända för de flesta Java-programmerare är det tillrådligt att använda dem sparsamt.

streck

Från och med Java 7 är understreck tillåtna inom siffrasträngarna i alla tre former av flytande punktbokstav. Detta gäller även "exponenten" -delarna. Se Använda understreck för att förbättra läsbarheten .

Speciella fall

Det är ett sammanställningsfel om en flytande punkt bokstavligen anger ett tal som är för stort eller för litet för att representera i den valda representationen; dvs om antalet skulle flyta över till + INF eller -INF, eller underflödet till 0,0. Det är emellertid lagligt för en bokstavlig att representera ett icke-noll denormaliserat tal.

Den bokstavliga syntaxen med flytande punkt tillhandahåller inte bokstavliga representationer för IEEE 754-specialvärden såsom INF- och NaN-värdena. Om du behöver uttrycka dem i källkod är det rekommenderade sättet att använda de konstanter som definieras av java.lang.Float och java.lang.Double ; t.ex. Float.NaN , Float.NEGATIVE_INFINITY och Float.POSITIVE_INFINITY .

Teckenbokstäver

Teckenbokstäver är det bekvämaste sättet att uttrycka char i Java-källkod. En bokstavstecken består av:

• En öppnande karaktär med en enda offert ( ' ).
• En representation av en karaktär. Denna representation kan inte vara en enda-offert eller ett linjebrytande tecken, men det kan vara en flykt-sekvens introducerad av ett backslash ( \ ) -tecken; se Escape-sekvenser i bokstavliga .
• En avslutande karaktär med en enda offert ( ' ).

Till exempel:

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

En radbrytning i en bokstavstecken är ett sammanställningsfel:

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