Java Literals: Numeric, Character, String, Boolean, and Other Forms

A literal is the fixed value you write directly in your source code. When you type 100 or 3.14 or "Java", you are not referring to a variable, you are writing the value itself.

int age = 25;
// 25 is an integer literal
double rate = 7.5;
// 7.5 is a floating-point literal
String city = "Pune";
// "Pune" is a String literal

A literal is the opposite of a variable in one important way: it can never change. There is no valid Java code that reassigns 25, because 25 is not a name, it is the value itself.

VARIABLE VERSUS LITERAL

   int  age    = 25;
   |   |    |    |
   |   |    |    +--> LITERAL     a fixed value, cannot change
   |   |    +-------> assignment  copies it into the box
   |   +------------> VARIABLE    a name you can change later
   +----------------> TYPE        always int here

   age = 26;          works, you changed the variable
   25 = 26;           ERROR, you cannot change a literal

Literals matter more than they look, because the compiler uses them to decide the type of everything around them. A literal is the starting point of Java's whole type system.

Java recognises six broad forms of literal, and every value you write in code belongs to one of them.

There is also a seventh form that beginners rarely meet, the class literal such as String.class, which we cover towards the end.

An integer literal is any whole number written in code. Java can read it in four different bases, and the base decides how the digits are interpreted.

THE NUMBER 100 WRITTEN IN FOUR BASES DECIMAL OCTAL HEXADECIMAL BINARY(no prefix)(0 prefix)(0x prefix)(0b prefix) 100 0144 0x64 0b0110 0100 | | | | +---------------+---------------+----------------+ all four store the same value

public class IntegerLiterals {
    public static void main(String[] args) {
        int decimal = 100;
        int octal = 0144;
        // leading zero means octal
        int hex = 0x64;
        // 0x means hexadecimal
        int binary = 0b01100100;
        // 0b means binary, Java 7 and later
        System.out.println(decimal);
        // 100
        System.out.println(octal);
        // 100
        System.out.println(hex);
        // 100
        System.out.println(binary);
        // 100
    }
}

• Hexadecimal letters are written in either case, so 0xCAFE and 0xcafe mean the same thing.

• An octal literal that contains an 8 or a 9 is an error, so 0789 will not compile.

• Java 7 added the binary prefix, and Java 7 also added underscores, which we look at next.

• There is one delightful quirk here. Because 0x80000000 is the most negative int value, writing int x = 0x80000000; gives you -2147483648, with no minus sign in sight.

Since Java 7 you may place underscores anywhere between digits in a numeric literal. The compiler ignores them completely, so the value is unchanged.

HARD TO READ EASY TO READ-------------------------------------------4532750012345678 4_532_7500_1234_56782147483647 2_147_483_6471000000 1_000_0000xFFECDE5E 0xFF_EC_DE_5E0b1010100011110000 0b1010_1000_1111_0000

The rule is simple: an underscore must sit **between two digits**. These are all illegal and produce a compile error.

• A leading underscore, as in _100

• A trailing underscore, as in 100_

• An underscore directly after a base prefix, so write 0xFF and never 0_xFF

Interestingly, Java tolerates consecutive underscores, so 1__0 is legal, and it also allows one right after the leading 0 of an octal literal, so 0_144 is legal too. The compiler simply ignores all of it.

public class UnderscoreDemo {
    public static void main(String[] args) {
        long phone = 9_876_543_210L;
        int mask = 0xFF_EC_DE_5E;
        byte small = 0b0000_1111;
        System.out.println(phone + " " + mask + " " + small);
        // _100, 100_ and 0_xFF would all fail to compile
    }
}

This is the rule beginners get wrong most often, and it surprises almost everyone. An integer literal is a plain int unless you say otherwise. It is never promoted to long automatically just because the number is large.

HOW JAVA TYPES AN INTEGER LITERAL Does the literal have an L or l suffix? | +-----+-----+ | | yes no | | v v long int(always)(always, even for a huge number) A bare literal larger than 2147483647 is simply a COMPILE ERROR, not an automatic long.

public class LiteralTypes {
    public static void main(String[] args) {
        int small = 100;
        // an int, as always
        long forced = 100L;
        // the L suffix makes it a long
        long big = 10000000000L;
        // the L is REQUIRED here
        long upper = 0xCAFEBABEL;
        // hex literals can also take L
        System.out.println(small);
        System.out.println(forced);
        System.out.println(big);
        System.out.println(upper);
        // long broken = 10000000000;    ERROR, no L suffix so it tries int
    }
}

• The suffix may be written L or l, and L is preferred because a lowercase l is easily mistaken for the digit 1.

• A bare integer literal is a compile error as soon as it exceeds 2147483647, so 10000000000 will not compile and neither will long x = 10000000000.

• Hexadecimal, octal and binary literals accept the same L suffix, as in 0xCAFEBABEL.

• The one special case is the literal 2147483648. The JLS allows it only as the operand of a unary minus, which is what makes Integer.MIN_VALUE writable as -2147483648.

A floating-point literal holds a decimal value. The most important rule is that a decimal with no suffix is always a double, never a float.

FLOATING-POINT FORMS 3.14 a double, because no suffix was given 3.14f a float, because of the f suffix 3.14d a double written explicitly 1.5e10 scientific notation, also a double 3.2e-8 a small number written with a negative exponent 1_000.5 underscores are allowed here too

public class FloatingLiterals {
    public static void main(String[] args) {
        double price = 1499.99;
        double big = 1.5e10;
        // 15,000,000,000
        double small = 3.2e-8;
        float ratio = 0.75f;
        // f is required to get a float
        double grouped = 1_000_000.5;
        System.out.println(price + " " + big + " " + small);
        System.out.println(ratio + " " + grouped);
    }
}

• Scientific notation uses e or E, and the exponent may be negative, as in 3.2e-8.

• You cannot assign a plain double literal straight into a float, because the compiler rejects it as a lossy conversion. The f suffix is the correct fix, and a (float) cast also works but discards precision.

• Float keeps only about seven significant digits, while double keeps about sixteen, which is why accumulating values into a float drifts much sooner.

• Java also accepts hexadecimal floating-point literals such as 0x1.8p3, but almost nobody uses them, so keep that one as background knowledge.

A character literal holds exactly one character and must use single quotes. Some characters cannot be typed directly, either because they are invisible or because they have a special meaning in code, so Java provides escape sequences for them.

public class EscapeDemo {
    public static void main(String[] args) {
        char newline = '\n';
        char tab = '\t';
        char backslash = '\\';
        char quote = '\'';
        char unicode = 'A';
        System.out.println("First line" + newline + "Second line");
        System.out.print("Name:" + tab + "Tanmoy" + newline);
        System.out.println("backslash = " + backslash);
        System.out.println("quote = " + quote);
        System.out.println("unicode A = " + unicode);
    }
}

Note the doubling. To print one backslash you must write two, and to hold a single quote inside a char literal you must write it escaped. This is the single most common source of syntax errors in string work.

A backslash u followed by exactly four hexadecimal digits is a Unicode escape, and the compiler translates it before it parses anything else. That last part causes genuine confusion.

WHY A UNICODE ESCAPE IN A COMMENT BREAKS THE BUILD You write: // remember to use \\u0041 for the letter A
Compiler: replaces \\u0041 with the letter A FIRST, before it even looks at what a comment is Result: your comment silently changed, harmless here WORSE CASE: // line one \\u000A line two
Compiler: \\u000A turns into a real line terminator Result: the next word lands on a new line, javac fails, and the error points at the wrong place Rule: the backslash-u sequence is processed everywhere, including comments. Never paste one into a comment.

public class UnicodeDemo {
    public static void main(String[] args) {
        char copyright = '©';
        // direct, and easiest
        char greek = 'Ω';
        // also direct
        char a = 'A';
        // the explicit escape form
        System.out.println(copyright + " " + greek + " " + a);
        System.out.println("To print a backslash then u, write: " + "\\u0041");
    }
}

• Prefer typing or pasting the character itself, because it reads better than an escape.

• Every Unicode escape must have exactly four hexadecimal digits.

• Never paste a backslash-u sequence into a comment, because the compiler acts on it there too.

A String literal is any text written in double quotes. It can hold any number of characters, it accepts the same escape sequences as a char, and it produces a String object rather than a primitive.

public class StringLiterals {
    public static void main(String[] args) {
        String simple = "Hello";
        String path = "C:\\Program Files\\Java";
        String quoted = "She said \"hello\" to me";
        String newline = "Line one\nLine two";
        String empty = "";
        System.out.println(simple + " " + path);
        System.out.println(quoted);
        System.out.println(newline);
        System.out.println("empty length = " + empty.length());
    }
}

Java quietly reuses String literals through something called the string pool. Two identical literals usually point at the very same object, which is why comparing them with equals gives true.

String first = "Java";
String second = "Java";
System.out.println(first.equals(second));
// true, same characters
System.out.println("pooling means: " +(first == second));
// usually true
String forced = new String("Java");
System.out.println("with new: " +(forced == first));
// false

Java 15 gave us text blocks, written with three double quotes. They are the cleanest way to embed JSON, SQL or HTML in code, because the formatting is preserved exactly and nothing needs escaping.

public class TextBlockDemo {
    public static void main(String[] args) {
        String json = """
                {
                  "status": "success",
                  "code": 200
                }
                """;
        String sql = """
                SELECT name, salary
                FROM employees
                WHERE department = 'IT'
                """;
        System.out.println(json);
        System.out.println(sql);
    }
}

• The opening triple quote must be followed by a line break, which the compiler then discards.

• Incidental indentation is stripped automatically, so your code stays neat.

• Quotes inside the block do not need escaping, which removes the ugliest part of embedded strings.

• Add a backslash on the opening line if you want to keep the closing delimiter on the same line.

Java has exactly two boolean literals and exactly one null literal, and every one of them must be written in lower case.

• true and false are the only boolean literals. TRUE, True and FALSE will not compile.

• null is a literal rather than a keyword, and it can only ever be assigned to a reference type.

public class BooleanAndNull {
    public static void main(String[] args) {
        boolean isReady = true;
        boolean hasFailed = false;
        String nickname = null;
        int[] scores = null;
        System.out.println(isReady + " " + hasFailed);
        System.out.println("nickname is null? " +(nickname == null));
        // boolean wrong = TRUE;    ERROR, must be lower case
        // int count = null;         ERROR, null cannot go into a primitive
    }
}

Null deserves care rather than fear. It simply means no object has been assigned yet, so any attempt to use the variable throws a NullPointerException. Checking before you use it is the whole habit.

A class literal is written with the word class after a type name. It always gives back a Class object, and it is genuinely useful in reflection, frameworks and unit tests.

public class ClassLiteralDemo {
    public static void main(String[] args) {
        System.out.println(String.class.getName());
        // java.lang.String
        System.out.println(int.class.getName());
        // int
        System.out.println(int[].class.getName());
        // [I  (an internal form)
        System.out.println(int[].class.getSimpleName());
        // int[]  (readable)
        System.out.println(String.class == String.class);
        // true
        // Handy when you want to build a message from a type
        String label = Integer.class.getSimpleName();
        // Integer
        System.out.println("Label: " + label);
    }
}

• String.class, int.class and int[].class all produce a Class object.

• Be careful with arrays. int[].class.getName() returns the internal form [I, while getSimpleName() returns the friendly int[]. An ordinary class such as String gives java.lang.String from getName().

• Class literals are not affected by autoboxing, and they never return null.

• A method reference such as String::length is a different idea, but you will meet it in the same chapter of the language.

• Mixing single and double quotes is the most common syntax error beginners make.

• Forgetting the double backslash in a Windows path is the most common logic error, because it still compiles and simply prints the wrong thing.

• Forgetting the L suffix produces a confusing error about a number too large, not about a missing suffix.

With literals clear, the next topic, constants in Java, is a natural next step, because a constant is simply a value you give a name to so the literal appears in one place only.