What is the char type and how does Java handle Unicode?

Three facts about char:

• 16-bit unsigned. Range is 0 to 65,535. It holds one UTF-16 code unit, not necessarily one visible character.
• BMP characters fit in one char. English letters, digits, currency symbols like ₹, Chinese/Japanese/Korean characters all fit.
• Supplementary characters need two chars. Emoji like 😀 and rare scripts have code points above 65,535 and are encoded as a surrogate pair (high surrogate + low surrogate).

What is a char?

A char in Java is a 16-bit unsigned integer type. It holds one UTF-16 code unit, which is a number from 0 to 65,535.

char letter = 'A';           // code point 65
char digit = '5';            // code point 53
char rupee = '₹';            // code point 8377 (U+20B9)
char unicode = '\u0041';     // Unicode escape: also 'A'

System.out.println((int) letter);  // 65
System.out.println((int) rupee);   // 8377

Because char is numeric, it can participate in arithmetic:

char a = 'A';
int next = a + 1;              // 65 + 1 = 66 (int)
char b = (char)(a + 1);        // cast back to char: 'B'
System.out.println(b);          // B

What is UTF-16 and why does it matter?

Unicode assigns a number (code point) to every character. The first 65,536 code points (U+0000 to U+FFFF) are called the Basic Multilingual Plane (BMP). These fit in a single 16-bit char.

Characters with code points above U+FFFF (supplementary characters) do not fit in one char. UTF-16 encodes them as a surrogate pair: two chars, a high surrogate (0xD800–0xDBFF) followed by a low surrogate (0xDC00–0xDFFF).

String emoji = "😀";  // U+1F600, code point 128512
System.out.println(emoji.length());         // 2 (two code units!)
System.out.println(emoji.codePointCount(0, emoji.length())); // 1 (one character)
System.out.println(emoji.codePointAt(0));   // 128512

char high = emoji.charAt(0);  // 0xD83D (high surrogate)
char low = emoji.charAt(1);   // 0xDE00 (low surrogate)
System.out.println(Character.isHighSurrogate(high));  // true
System.out.println(Character.toCodePoint(high, low)); // 128512

Why does String.length() give the wrong count?

length() counts code units (chars), not visible characters. For strings with emoji or supplementary characters, the count is wrong.

String name = "Rajesh";     // 6 BMP chars
String withEmoji = "Hi 😀"; // 3 BMP chars + 1 emoji (2 code units)

System.out.println(name.length());      // 6 (correct)
System.out.println(withEmoji.length()); // 5 (WRONG: visible is 4)
System.out.println(withEmoji.codePointCount(0, withEmoji.length())); // 4 (correct)

In banking, customer names from some regions may contain supplementary characters. Always use codePointCount() when the true character count matters.

How do you iterate over characters correctly?

// WRONG: charAt() can return half a surrogate
for (int i = 0; i < str.length(); i++) {
    char c = str.charAt(i);  // may be half an emoji
}

// CORRECT: iterate by code points
str.codePoints().forEach(cp -> {
    System.out.println(Character.toString(cp));
});

// CORRECT: manual code point iteration
for (int i = 0; i < str.length(); ) {
    int cp = str.codePointAt(i);
    System.out.println(Character.toString(cp));
    i += Character.charCount(cp);  // 1 for BMP, 2 for supplementary
}

What happens if you truncate a String by char index?

If you cut a string at a char index that falls between the two halves of a surrogate pair, you get a broken character.

String text = "Account: 😀 Active";
String truncated = text.substring(0, 10);  // might split the emoji
System.out.println(truncated);  // "Account: ?" (broken surrogate)

// SAFE: use offsetByCodePoints
int safeEnd = text.offsetByCodePoints(0, 10);
String safeTruncated = text.substring(0, safeEnd);

In banking, this matters when truncating customer names or messages for display.

What Character utility methods exist?

System.out.println(Character.isLetter('A'));       // true
System.out.println(Character.isDigit('5'));         // true
System.out.println(Character.isWhitespace(' '));    // true
System.out.println(Character.toUpperCase('a'));     // A
System.out.println(Character.toLowerCase('Z'));     // z
System.out.println(Character.isHighSurrogate('\uD83D')); // true
System.out.println(Character.charCount(128512));   // 2 (supplementary)
System.out.println(Character.charCount(65));       // 1 (BMP)

What are common mistakes?

• Assuming length() counts visible characters. It counts code units. Use codePointCount() for true count.
• Using charAt() for iteration. It returns one code unit, which may be half an emoji. Use codePoints() stream.
• Truncating by char index. Can split surrogate pairs. Use offsetByCodePoints().
• Comparing chars with ==. Works for BMP but not for supplementary (which are int code points). Use codePointAt() and compare ints.

What should a senior engineer know?

• Java chose UTF-16 in 1995 when Unicode had fewer than 65,536 characters. Supplementary characters were added later, which is why Java's char does not hold all characters.
• Kotlin and Swift use proper Unicode abstractions. Kotlin's String.length also counts code units, but String.codePointCount() and the codePoints stream handle it correctly.
• Database VARCHAR length counts bytes or characters depending on the encoding. When storing emoji, make sure the column uses UTF-8 MB4 (MySQL) or nvarchar (SQL Server).
• JSON and HTTP use UTF-8, not UTF-16. Java converts between UTF-16 (internal) and UTF-8 (network) automatically, but emoji in JSON may surprise parsers that expect ASCII.