1. A translation of Unicode escapes (§3.3) in the raw stream of Unicode characters to the corresponding Unicode character. A Unicode escape of the form\uxxxx, wherexxxx is a hexadecimal value, represents the UTF-16 code unit whose encoding isxxxx. This translation step allows any program to be expressed using only ASCII characters.

2. A translation of the Unicode stream resulting from step 1 into a stream of input characters and line terminators (§3.4).

3. A translation of the stream of input characters and line terminators resulting from step 2 into a sequence of input elements (§3.5) which, after white space (§3.6) and comments (§3.7) are discarded, comprise the tokens that are the terminal symbols of the syntactic grammar (§2.3).

• If the most recent raw input character in the result was itself translated from a Unicode escape in the compiler's raw input, then the ASCII\ character is eligible to begin a Unicode escape.

  For example, if the most recent raw input character in the result was a backslash that arose from a Unicode escape\u005c in the raw input, then an ASCII\ character appearing next in the raw input is eligible to begin another Unicode escape.

• Otherwise, consider how many backslashes appeared contiguously as raw input characters in the result, back to a non-backslash character or the start of the result. (It is immaterial whether any such backslash arose from an ASCII\ character in the compiler's raw input or from a Unicode escape\u005c in the compiler's raw input.) If this number is even, then the ASCII\ character is eligible to begin a Unicode escape; if the number is odd, then the ASCII\ character is not eligible to begin a Unicode escape.

  For example, the raw input"\\u2122=\u2122" results in the eleven characters" \ \ u 2 1 2 2 = ™ " because while the second ASCII\ character in the raw input is not eligible to begin a Unicode escape, the third ASCII\ character is eligible, and\u2122 is the Unicode encoding of the character™.

For example, the raw input\u005cu005a results in the six characters\ u 0 0 5 a, because005c is the Unicode value for a backslash. It does not result in the characterZ, which is Unicode value005a, because the backslash that resulted from processing the Unicode escape\u005c is not interpreted as the start of a further Unicode escape.

Note that\u005cu005a cannot be written in a string literal to denote the six characters\ u 0 0 5 a. This is because the first two characters resulting from translation,\ andu, are interpreted in a string literal as an illegal escape sequence (§3.10.7).

Fortunately, the rule about contiguous backslash characters helps programmers to craft raw inputs that denote Unicode escapes in a string literal. Denoting the six characters\ u 0 0 5 a in a string literal simply requires another\ to be placed adjacent to the existing\, such as"\\u005a is Z". This works because the second\ in the raw input\\u005a is not eligible to begin a Unicode escape, so the first\ and the second\ are preserved as raw input characters, as are the next five charactersu 0 0 5 a. The two\ characters are subsequently interpreted in a string literal as the escape sequence for a backslash, resulting in a string with the desired six characters\ u 0 0 5 a. Without the rule, the raw input\\u005a would be processed as a raw input character\ followed by a Unicode escape\u005a which becomes a raw input characterZ; this would be unhelpful because\Z is an illegal escape sequence in a string literal. (Note that the rule translates\u005c\u005c to\\ because the translation of the first Unicode escape to a raw input character\ does not prevent the translation of the second Unicode escape to another raw input character\.)

The rule also allows programmers to craft raw inputs that denote escape sequences in a string literal. For example, the raw input\\\u006e results in the three characters\ \ n because the first\ and the second\ are preserved as raw input characters, while the third\ is eligible to begin a Unicode escape and thus\u006e is translated to a raw input charactern. The three characters\ \ n are subsequently interpreted in a string literal as\ n which denotes the escape sequence for a linefeed. (Note that\\\u006e may be written as\u005c\u005c\u006e because each Unicode escape\u005c is translated to a raw input character\ and so the remaining raw input\u006e is preceded by an even number of backslashes and processed as the Unicode escape forn.)

• A sequence of input characters that could be reduced to either an identifier token or a literal token is always reduced to a literal token.

• A sequence of input characters that could be reduced to either an identifier token or a reserved keyword token (§3.9) is always reduced to a reserved keyword token.

• A sequence of input characters that could be reduced to either a contextual keyword token or to other (non-keyword) tokens is reduced according to context, as specified in§3.9.

• If the input character> appears in a type context (§4.11), that is, as part of aType or anUnannType in the syntactic grammar (§4.1,§8.3), it is always reduced to the numerical comparison operator>, even when it could be combined with an adjacent> character to form a different operator.

  Without this rule for> characters, two consecutive> brackets in a type such asList<List<String>> would be tokenized as the signed right shift operator>>, while three consecutive> brackets in a type such asList<List<List<String>>> would be tokenized as the unsigned right shift operator>>>. Worse, the tokenization of four or more consecutive> brackets in a type such asList<List<List<List<String>>>> would be ambiguous, as various combinations of>,>>, and>>> tokens could represent the>>>> characters.

For example, in this simple piece of code:

class Empty {}

we say that the} token is to the right of the{ token, even though it appears, in this two-dimensional representation, downward and to the left of the{ token. This convention about the use of the words left and right allows us to speak, for example, of the right-hand operand of a binary operator or of the left-hand side of an assignment.

• /*text*/

  Atraditional comment: all the text from the ASCII characters/* to the ASCII characters*/ is ignored (as in C and C++).

• //text

  Anend-of-line comment: all the text from the ASCII characters// to the end of the line is ignored (as in C++).

• Comments do not nest.

• /* and*/ have no special meaning in comments that begin with//.

• // has no special meaning in comments that begin with/* or/**.

As a result, the following text is a single complete comment:

/* this comment /* // /** ends here: */

For example, the identifiers consisting of the single letters LATIN CAPITAL LETTER A (A,\u0041), LATIN SMALL LETTER A (a,\u0061), GREEK CAPITAL LETTER ALPHA (A,\u0391), CYRILLIC SMALL LETTER A (a,\u0430) and MATHEMATICAL BOLD ITALIC SMALL A (a,\ud835\udc82) are all different.

Unicode composite characters are different from their canonical equivalent decomposed characters. For example, a LATIN CAPITAL LETTER A ACUTE (Á,\u00c1) is different from a LATIN CAPITAL LETTER A (A,\u0041) immediately followed by a NON-SPACING ACUTE (´,\u0301) in identifiers. See The Unicode Standard, Section 3.11 "Normalization Forms".

Examples of identifiers are:

1. The sequence is recognized as a terminal specified in a suitable context of the syntactic grammar (§2.3), as follows:

   • Formodule andopen, when recognized as a terminal in aModuleDeclaration (§7.7).

   • Forexports,opens,provides,requires,to,uses, andwith, when recognized as a terminal in aModuleDirective.

   • Fortransitive, when recognized as a terminal in aRequiresModifier.

     For example, recognizing the sequencerequirestransitive; does not make use ofRequiresModifier, so the termtransitive is reduced here to an identifier and not a contextual keyword.

   • Forvar, when recognized as a terminal in aLocalVariableType (§14.4) or aLambdaParameterType (§15.27.1).

     In other contexts, attempting to usevar as an identifier will cause an error, becausevar is not aTypeIdentifier (§3.8).

   • Foryield, when recognized as a terminal in aYieldStatement (§14.21).

     In other contexts, attempting to use theyield as an identifier will cause an error, becauseyield is neither aTypeIdentifier nor aUnqualifiedMethodIdentifier.

   • Forrecord, when recognized as a terminal in aRecordDeclaration (§8.10).

   • Fornon-sealed,permits, andsealed, when recognized as a terminal in aNormalClassDeclaration (§8.1) or aNormalInterfaceDeclaration (§9.1).

2. The sequence is not immediately preceded or immediately followed by an input character that matchesJavaLetterOrDigit.

Aninteger literal may be expressed in decimal (base 10), hexadecimal (base 16), octal (base 8), or binary (base 2).

An integer literal is of typelong if it is suffixed with an ASCII letterL orl (ell); otherwise it is of typeint (§4.2.1).

The suffixL is preferred, because the letterl (ell) is often hard to distinguish from the digit1 (one).

Underscores are allowed as separators between digits that denote the integer.

In a hexadecimal or binary literal, the integer is only denoted by the digits after the0x or0b characters and before any type suffix. Therefore, underscores may not appear immediately after0x or0b, or after the last digit in the numeral.

In a decimal or octal literal, the integer is denoted byall the digits in the literal before any type suffix. Therefore, underscores may not appear before the first digit or after the last digit in the numeral. Underscores may appear after the initial0 in an octal numeral (since0 is a digit that denotes part of the integer) and after the initial non-zero digit in a non-zero decimal literal.

A decimal numeral is either the single ASCII digit0, representing the integer zero, or consists of an ASCII digit from1 to9 optionally followed by one or more ASCII digits from0 to9 interspersed with underscores, representing a positive integer.

A hexadecimal numeral consists of the leading ASCII characters0x or0X followed by one or more ASCII hexadecimal digits interspersed with underscores, and can represent a positive, zero, or negative integer.

Hexadecimal digits with values 10 through 15 are represented by the ASCII lettersa throughf orA throughF, respectively; each letter used as a hexadecimal digit may be uppercase or lowercase.

TheHexDigit production above comes from§3.3.

An octal numeral consists of an ASCII digit0 followed by one or more of the ASCII digits0 through7 interspersed with underscores, and can represent a positive, zero, or negative integer.

Note that octal numerals always consist of two or more digits, as0 alone is always considered to be a decimal numeral - not that it matters much in practice, for the numerals0,00, and0x0 all represent exactly the same integer value.

A binary numeral consists of the leading ASCII characters0b or0B followed by one or more of the ASCII digits0 or1 interspersed with underscores, and can represent a positive, zero, or negative integer.

The largest decimal literal of typeint is2147483648 (2³¹).

All decimal literals from0 to2147483647 may appear anywhere anint literal may appear. The decimal literal2147483648 may appear only as the operand of the unary minus operator- (§15.15.4).

It is a compile-time error if the decimal literal2147483648 appears anywhere other than as the operand of the unary minus operator; or if a decimal literal of typeint is larger than2147483648 (2³¹).

The largest positive hexadecimal, octal, and binary literals of typeint - each of which represents the decimal value2147483647 (2³¹-1) - are respectively:

The most negative hexadecimal, octal, and binary literals of typeint - each of which represents the decimal value-2147483648 (-2³¹) - are respectively:

The following hexadecimal, octal, and binary literals represent the decimal value-1:

It is a compile-time error if a hexadecimal, octal, or binaryint literal does not fit in 32 bits.

The largest decimal literal of typelong is9223372036854775808L (2⁶³).

All decimal literals from0L to9223372036854775807L may appear anywhere along literal may appear. The decimal literal9223372036854775808L may appear only as the operand of the unary minus operator- (§15.15.4).

It is a compile-time error if the decimal literal9223372036854775808L appears anywhere other than as the operand of the unary minus operator; or if a decimal literal of typelong is larger than9223372036854775808L (2⁶³).

The largest positive hexadecimal, octal, and binary literals of typelong - each of which represents the decimal value9223372036854775807L (2⁶³-1) - are respectively:

The most negative hexadecimal, octal, and binary literals of typelong - each of which represents the decimal value-9223372036854775808L (-2⁶³) - are respectively:

The following hexadecimal, octal, and binary literals represent the decimal value-1L:

It is a compile-time error if a hexadecimal, octal, or binarylong literal does not fit in 64 bits.

0    2    0372    0xDada_Cafe    1996    0x00_FF__00_FF

0l    0777L    0x100000000L    2_147_483_648L    0xC0B0L

Afloating-point literal has the following parts: a whole-number part, a decimal or hexadecimal point (represented by an ASCII period character), a fraction part, an exponent, and a type suffix.

A floating-point literal may be expressed in decimal (base 10) or hexadecimal (base 16).

For decimal floating-point literals, at least one digit (in either the whole number or the fraction part) and either a decimal point, an exponent, or a float type suffix are required. All other parts are optional. The exponent, if present, is indicated by the ASCII lettere orE followed by an optionally signed integer.

For hexadecimal floating-point literals, at least one digit is required (in either the whole number or the fraction part), and the exponent is mandatory, and the float type suffix is optional. The exponent is indicated by the ASCII letterp orP followed by an optionally signed integer.

Underscores are allowed as separators between digits that denote the whole-number part, and between digits that denote the fraction part, and between digits that denote the exponent.

A floating-point literal is of typefloat if it is suffixed with an ASCII letterF orf; otherwise its type isdouble and it can optionally be suffixed with an ASCII letterD ord.

The elements of the typesfloat anddouble are those values that can be represented using the IEEE 754 binary32 and IEEE 754 binary64 floating-point formats, respectively (§4.2.3).

The details of proper input conversion from a Unicode string representation of a floating-point number to the internal IEEE 754 binary floating-point representation are described for the methodsvalueOf of classFloat and classDouble of the packagejava.lang.

The largest and smallest positive literals of typefloat are as follows:

The largest and smallest positive literals of typedouble are as follows:

It is a compile-time error if a non-zero floating-point literal is too large, so that on rounded conversion to its internal representation, it becomes an IEEE 754 infinity.

A program can represent infinities without producing a compile-time error by using constant expressions such as1f/0f or-1d/0d or by using the predefined constantsPOSITIVE_INFINITY andNEGATIVE_INFINITY of the classesFloat andDouble.

It is a compile-time error if a non-zero floating-point literal is too small, so that, on rounded conversion to its internal representation, it becomes a zero.

A compile-time error does not occur if a non-zero floating-point literal has a small value that, on rounded conversion to its internal representation, becomes a non-zero subnormal number.

Predefined constants representing Not-a-Number values are defined in the classesFloat andDouble asFloat.NaN andDouble.NaN.

1e1f    2.f    .3f    0f    3.14f    6.022137e+23f

1e1    2.    .3    0.0    3.14    1e-9d    1e137

Theboolean type has two values, represented by theboolean literalstrue andfalse, formed from ASCII letters.

A boolean literal is always of typeboolean (§4.2.5).

Acharacter literal is expressed as a character or an escape sequence (§3.10.7), enclosed in ASCII single quotes. (The single-quote, or apostrophe, character is\u0027.)

A character literal is always of typechar (§4.2.1).

Thecontent of a character literal is theSingleCharacter or theEscapeSequence which follows the opening'.

It is a compile-time error for the character following the content to be other than a'.

It is a compile-time error for a line terminator (§3.4) to appear after the opening' and before the closing'.

The characters CR and LF are never anInputCharacter; each is recognized as constituting aLineTerminator, so may not appear in a character literal, even in the escape sequence\LineTerminator.

Thecharacter represented a character literal is the content of the character literal with any escape sequence interpreted, as if by execution ofString.translateEscapes on the content.

Character literals can only represent UTF-16 code units (§3.1), i.e., they are limited to values from\u0000 to\uffff. Supplementary characters must be represented either as a surrogate pair within achar sequence, or as an integer, depending on the API they are used with.

Because Unicode escapes are processed very early, it is not correct to write'\u000a' for a character literal whose value is linefeed (LF); the Unicode escape\u000a is transformed into an actual linefeed in translation step 1 (§3.3) and the linefeed becomes aLineTerminator in step 2 (§3.4), so the character literal is not valid in step 3. Instead, one should use the escape sequence'\n'. Similarly, it is not correct to write'\u000d' for a character literal whose value is carriage return (CR). Instead, use'\r'. Finally, it is not possible to write'\u0027' for a character literal containing an apostrophe (').

In C and C++, a character literal may contain representations of more than one character, but the value of such a character literal is implementation-defined. In the Java programming language, a character literal always represents exactly one character.

Astring literal consists of zero or more characters enclosed in double quotes. Characters such as newlines may be represented by escape sequences (§3.10.7).

A string literal is always of typeString (§4.3.3).

Thecontent of a string literal is the sequence of characters that begins immediately after the opening" and ends immediately before the matching closing".

It is a compile-time error for a line terminator (§3.4) to appear after the opening" and before the matching closing".

The characters CR and LF are never anInputCharacter; each is recognized as constituting aLineTerminator, so may not appear in a string literal, even in the escape sequence\LineTerminator.

The string represented by a string literal is the content of the string literal with every escape sequence interpreted, as if by execution ofString.translateEscapes on the content.

""                    // the empty string"\""                  // a string containing " alone"This is a string"    // a string containing 16 characters"This is a " +        // actually a string-valued constant expression,    "two-line string"    // formed from two string literals

Because Unicode escapes are processed very early, it is not correct to write"\u000a" for a string literal containing a single linefeed (LF); the Unicode escape\u000a is transformed into an actual linefeed in translation step 1 (§3.3) and the linefeed becomes aLineTerminator in step 2 (§3.4), so the string literal is not valid in step 3. Instead, one should use the escape sequence"\n". Similarly, it is not correct to write"\u000d" for a string literal containing a single carriage return (CR). Instead, use"\r". Finally, it is not possible to write"\u0022" for a string literal containing a double quotation mark (").

A long string literal can always be broken up into shorter pieces and written as a (possibly parenthesized) expression using the string concatenation operator+ (§15.18.1).

At run time, a string literal is a reference to an instance of classString (§4.3.3) that denotes the string represented by the string literal.

Moreover, a string literal always refers to thesame instance of classString. This is because string literals - or, more generally, strings that are the values of constant expressions (§15.29) - are "interned" so as to share unique instances, as if by execution of the methodString.intern (§12.5).

package testPackage;class Test {    public static void main(String[] args) {        String hello = "Hello", lo = "lo";        System.out.println(hello == "Hello");        System.out.println(Other.hello == hello);        System.out.println(other.Other.hello == hello);        System.out.println(hello == ("Hel"+"lo"));        System.out.println(hello == ("Hel"+lo));        System.out.println(hello == ("Hel"+lo).intern());    }}class Other { static String hello = "Hello"; }

package other;public class Other { public static String hello = "Hello"; }

truetruetruetruefalsetrue

Atext block consists of zero or more characters enclosed by opening and closing delimiters. Characters may be represented by escape sequences (§3.10.7), but the newline and double quote characters that must be represented with escape sequences in a string literal (§3.10.5) may be represented directly in a text block.

The following productions from§3.3,§3.4, and§3.6 are shown here for convenience:

A text block is always of typeString (§4.3.3).

Theopening delimiter is a sequence that starts with three double quote characters ("""), continues with zero or more space, tab, and form feed characters, and concludes with a line terminator.

Theclosing delimiter is a sequence of three double quote characters.

Thecontent of a text block is the sequence of characters that begins immediately after the line terminator of the opening delimiter, and ends immediately before the first double quote of the closing delimiter.

Unlike in a string literal (§3.10.5), it isnot a compile-time error for a line terminator to appear in the content of a text block.

String html = "<html>\n" +              "    <body>\n" +              "        <p>Hello, world</p>\n" +              "    </body>\n" +              "</html>\n";String html = """              <html>                  <body>                      <p>Hello, world</p>                  </body>              </html>              """;

class Test {    public static void main(String[] args) {        // The six characters w i n t e r        String season = """                        winter""";        // The seven characters w i n t e r LF        String period = """                        winter                        """;        // The ten characters H i , SP " B o b " LF        String greeting = """                          Hi, "Bob"                          """;        // The eleven characters H i , LF SP " B o b " LF        String salutation = """                            Hi,                             "Bob"                            """;                // The empty string (zero length)        String empty = """                       """;              // The two characters " LF        String quote = """                       "                       """;         // The two characters \ LF        String backslash = """                           \\                           """;      }}

Using the escape sequences\n and\" to represent a newline character and a double quote character, respectively, is permitted in a text block, though not usually necessary. The exception is where three consecutive double quote characters appear that are not intended to be the closing delimiter""" - in this case, it is necessary to escape at least one of the double quote characters in order to avoid mimicking the closing delimiter.

class Story1 {    public static void main(String[] args) {        String story = """            "When I use a word," Humpty Dumpty said,            in rather a scornful tone, "it means just what I            choose it to mean - neither more nor less."            "The question is," said Alice, "whether you            can make words mean so many different things."            "The question is," said Humpty Dumpty,            "which is to be master - that's all."        """;    }}

class Story2 {    public static void main(String[] args) {        String story = """            "When I use a word," Humpty Dumpty said,            in rather a scornful tone, "it means just what I            choose it to mean - neither more nor less."            "The question is," said Alice, "whether you            can make words mean so many different things."            "The question is," said Humpty Dumpty,            "which is to be master - that's all."""";  // error    }}

class Story3 {    public static void main(String[] args) {        String story = """            "When I use a word," Humpty Dumpty said,            in rather a scornful tone, "it means just what I            choose it to mean - neither more nor less."            "The question is," said Alice, "whether you            can make words mean so many different things."            "The question is," said Humpty Dumpty,            "which is to be master - that's all.\"""";  // OK    }}

class Code {    public static void main(String[] args) {        String text = """            The quick brown fox jumps over the lazy dog        """;        String code =            """            String text = \"""                The quick brown fox jumps over the lazy dog            \""";            """;    }}

The string represented by a text block isnot the literal sequence of characters in the content. Instead, the string represented by a text block is the result of applying the following transformations to the content, in order:

When this specification says that a text blockcontains a particular character or sequence of characters, or that a particular character or sequence of characters isin a text block, it means that the string represented by the text block (as opposed to the literal sequence of characters in the content) contains the character or sequence of characters.

String html = """              <html>\r                  <body>\r                      <p>Hello, world</p>\r                  </body>\r              </html>\r              """;

|<html>\u000D\u000A|    <body>\u000D\u000A|        <p>Hello, world</p>\u000D\u000A|    </body>\u000D\u000A|</html>\u000D\u000A

At run time, a text block is a reference to an instance of classString that denotes the string represented by the text block.

Moreover, a text block always refers to thesame instance of classString. This is because the strings represented by text blocks - or, more generally, strings that are the values of constant expressions (§15.29) - are "interned" so as to share unique instances, as if by execution of the methodString.intern (§12.5).

System.out.println("ab" + """                          cde                          """);String cde = """             abcde""".substring(2);String math = """              1+1 equals \              """ + String.valueOf(2);@Preconditions("""    rate > 0 &&    rate <= MAX_REFRESH_RATE""")public void setRefreshRate(int rate) { ... }

In character literals, string literals, and text blocks (§3.10.4,§3.10.5,§3.10.6), theescape sequences allow for the representation of some nongraphic characters without using Unicode escapes (§3.3), as well as the single quote, double quote, and backslash characters.

TheOctalDigit production above comes from§3.10.1. Octal escapes are provided for compatibility with C, but can express only Unicode values\u0000 through\u00FF, so Unicode escapes are usually preferred.

It is a compile-time error if the character following a backslash in an escape sequence is not aLineTerminator or an ASCIIb,s,t,n,f,r,",',\,0,1,2,3,4,5,6, or7.

An escape sequence in the content of a character literal, string literal, or text block isinterpreted by replacing its\ and trailing character(s) with the single character denoted by the Unicode escape in theEscapeSequence grammar. The line continuation escape sequence has no corresponding Unicode escape, so is interpreted by replacing it with nothing.

The line continuation escape sequence can appear in a text block, but cannot appear in a character literal or a string literal because each disallows aLineTerminator.

The null type has one value, the null reference, represented by thenull literalnull, which is formed from ASCII characters.

A null literal is always of the null type (§4.1).