Unicode System in Java

Older languages designed in the 1970s, such as C, generally used ASCII to represent characters — a 7-bit encoding covering only 128 characters, which is enough for basic English text but nothing else. Java was designed later, in the era of international software, so its designers chose Unicode as the character encoding from the very beginning.

Because of this, Java's char type is defined as a 16-bit unsigned value, not the 8-bit (or smaller) representation used in many older languages, and it represents a single Unicode code unit rather than a single ASCII byte.

Why it matters

Any program that handles names, addresses or messages will meet text beyond English letters. Java strings are Unicode from the start, but a char is not always a whole character, and that gap is where bugs in length checks, truncation and reversing strings come from.

Why 16-bit Unicode Matters

A 16-bit char can represent 65,536 distinct values, which is enough to cover the Basic Multilingual Plane of Unicode — including Latin letters, Greek, Cyrillic, Arabic, Devanagari, Chinese, Japanese, Korean characters, and many symbols. This lets a single Java String hold mixed-language text (for example, an English label right next to Japanese or Hindi text) without any special encoding tricks, which was a real limitation in older 8-bit character systems.

Unicode Escape Sequences

Any character can be written using its Unicode code point with the escape sequence \uXXXX, where XXXX is a four-digit hexadecimal value. For example, '\u0041' represents the character 'A', and '\u20B9' represents the Indian Rupee sign (₹). These escapes work directly inside char and String literals, and even, unusually, outside of literals in raw source code, since the compiler processes Unicode escapes before parsing any other syntax.

A Note on Supplementary Characters

Some rarer Unicode characters — mostly historic scripts and certain emoji — lie outside the Basic Multilingual Plane and require more than 16 bits to represent. Java handles these "supplementary characters" using a pair of two chars called a surrogate pair, which is why methods like codePointAt() exist alongside the older charAt() for correctly reading such characters.

Example

public class UnicodeDemo {
    public static void main(String[] args) {
        char letter = '\u0041';       // Unicode for 'A'
        char rupee = '\u20B9';        // Indian Rupee sign
        char devanagariKa = '\u0915'; // Devanagari letter for 'ka'

        System.out.println(letter);
        System.out.println(rupee);
        System.out.println(devanagariKa);
        System.out.println((int) letter);
    }
}

A
₹
क
65

Exercise

Explore how characters map to numbers. Complete the program so it prints the code of the letter A, the character with code 66, and the character written with the Unicode escape for 0041.

Expected output: 65, B, A, each on its own line.

public class UnicodeDemo {
    public static void main(String[] args) {
        char letter = 'A';
        // TODO: print the numeric code of letter
        // TODO: print the character whose code is 66
        // TODO: print the character written as the Unicode escape \u0041
    }
}

public class UnicodeDemo {
    public static void main(String[] args) {
        char letter = 'A';
        System.out.println((int) letter);   // 65
        System.out.println((char) 66);      // B
        System.out.println('\u0041');       // A
    }
}

Quick quiz

Interview questions