Literals
Navigate Language Fundamentals topic: ) 
Java Literals are syntactic representations of boolean, character, numeric, or string data. Literals provide a means of expressing specific values in your program. For example, in the following statement, an integer variable named count
is declared and assigned an integer value. The literal 0
represents, naturally enough, the value zero.
Code section 3.61: Numeric literal.

The code section 3.62 contains two number literals, followed by two boolean literals at line 1, one string literal, followed by one number literal at line 2 and one string literal, followed by one real number literal at line 3:
Code section 3.62: Literals.

Boolean Literals[edit]
There are two boolean literals
There are no other boolean literals, because there are no other boolean values!
Numeric Literals[edit]
There are three types of numeric literals in Java.
Integer Literals[edit]
In Java, you may enter integer numbers in several formats:
 As decimal numbers such as
1995
,51966
. Negative decimal numbers such as42
are actually expressions consisting of the integer literal with the unary negation operation
.  As octal numbers, using a leading
0
(zero) digit and one or more additional octal digits (digits between0
and7
), such as077
. Octal numbers may evaluate to negative numbers; for example037777777770
is actually the decimal value 8.  As hexadecimal numbers, using the form
0x
(or0X
) followed by one or more hexadecimal digits (digits from0
to9
,a
tof
orA
toF
). For example, 0xCAFEBABEL is the long integer 3405691582. Like octal numbers, hexadecimal literals may represent negative numbers.  Starting in J2SE 7.0, as binary numbers, using the form
0b
(or0B
) followed by one or more binary digits (0 or 1). For example, 0b101010 is the integer 42. Like octal and hex numbers, binary literals may represent negative numbers.
By default, the integer literal primitive type is int
. If you want a long
, add a letter el suffix (either the character l
or the character L
) to the integer literal. This suffix denotes a long integer rather than a standard integer. For example, 3405691582L
is a long integer literal. Long integers are 8 bytes in length as opposed to the standard 4 bytes for int
. It is best practice to use the suffix L
instead of l
to avoid confusion with the digit 1
(one) which looks like l
in many fonts: 200l
≠ 2001
. If you want a short integer literal, you have to cast it.
Starting in J2SE 7.0, you may insert underscores between digits in a numeric literal. They are ignored but may help readability by allowing the programmer to group digits.
Floating Point Literals[edit]
Floating point numbers are expressed as decimal fractions or as exponential notation:
Code section 3.63: Floating point literals.

Floating point numbers consist of:
 an optional leading
+
or
sign, indicating a positive or negative value; if omitted, the value is positive,  one of the following number formats
 integer digits (must be followed by either an exponent or a suffix or both, to distinguish it from an integer literal)
 integer digits
.
 integer digits
.
integer digits .
integer digits
 an optional exponent of the form
 the exponent indicator
e
orE
 an optional exponent sign
+
or
(the default being a positive exponent)  integer digits representing the integer exponent value
 the exponent indicator
 an optional floating point suffix:
 either
f
orF
indicating a single precision (4 bytes) floating point number, or d
orD
indicating the number is a double precision floating point number (by default, thus the double precision (8 bytes) is default).
 either
Here, integer digits represents one or more of the digits 0
through 9
.
Starting in J2SE 7.0, you may insert underscores between digits in a numeric literal. They are ignored but may help readability by allowing the programmer to group digits.
Character Literals[edit]
Character literals are constant valued character expressions embedded in a Java program. Java characters are sixteen bit Unicode characters, ranging from 0 to 65535. Character literals are expressed in Java as a single quote, the character, and a closing single quote ('a'
, '7'
, '$'
, 'π'
). Character literals have the type char
, an unsigned integer primitive type. Character literals may be safely promoted to larger integer types such as int
and long
. Character literals used where a short
or byte
is called for must be cast to short
or byte
since truncation may occur.
String Literals[edit]
String literals consist of the double quote character ("
) (ASCII 34, hex 0x22), zero or more characters (including Unicode characters), followed by a terminating double quote character ("
), such as: "Ceci est une string."
So a string literal follows the following grammar:
<STRING : "\"" ( (~["\"","\\","\n","\r"]) ("\\" ( ["n","t","b","r","f","\\","'","\""] ["0""7"](["0""7"])? ["0""3"]["0""7"]["0""7"] ) ) )* "\"">
Within string and character literals, the backslash character can be used to escape special characters, such as unicode escape sequences, or the following special characters:
Name  Character  ASCII  hex 

Backspace  \b 
8  0x08 
TAB  \t 
9  0x09 
NUL character  \0 
0  0x00 
newline  \n 
10  0x0a 
carriage control  \r 
13  0xd 
double quote  \" 
34  0x22 
single quote  \' 
39  0x27 
backslash  \\ 
92  0x5c 
String literals may not contain unescaped newline or linefeed characters. However, the Java compiler will evaluate compile time expressions, so the following String expression results in a string with three lines of text:
Code section 3.64: Multiline string.

null[edit]
null
is a special Java literal which represents a null value: a value which does not refer to any object. It is an error to attempt to dereference the null value — Java will throw a NullPointerException
. null
is often used to represent uninitialized state.
Mixed Mode Operations[edit]
In concatenation operations, the values in brackets are concatenated first. Then the values are concatenated from the left to the right. Be careful when mixing character literals and integers in String concatenation operations:


The unexpected results arise because '1'
and '0'
are converted twice. The expression is concatenated as such:
"120? " + one + '2' + zero 
"120? " + 49 + '2' + 48 
"120? 49" + '2' + 48 
"120? 492" + 48 
"120? 49248" 
one
andzero
are integers. So they store integer values. The integer value of'1'
is 49 and the integer value of'0'
is 48. So the first concatenation concatenates
"120? "
and49
.49
is first converted into String, yielding"49"
and the concatenation returns the string"120? 49"
.  The second concatenation concatenates
"120? 49"
and'2'
.'2'
is converted into the String"2"
and the concatenation returns the string"120? 492"
.  The concatenation between
"120? 492"
and'0'
returns the string"120? 49248"
.
The code section 66 yields the desired result:


Question 3.9: Consider the following code:


Explain the results seen.
For the first line:
" 3? " + (one + '2' + zero) 
" 3? " + (49 + '2' + 48) 
" 3? " + (99 + 48) 
" 3? " + 147 
" 3? 147" 
For the second line:
"102? " + 100 + '2' + 0 
"102? 100" + '2' + 0 
"102? 1002" + 0 
"102? 10020" 
For the last line:
"102? " + (100 + '2' + 0) 
"102? " + (150 + 0) 
"102? " + 150 
"102? 150" 