Java Character Class – Methods with Use & Description

Package: java.lang
Type: final class Character implements Serializable, Comparable<Character>

The Character class is a wrapper class for the primitive char and provides static utility methods for character analysis, validation, Unicode handling, and conversion.

1. Character Value & Object Methods

char charValue()

Use: Returns primitive char value from Character object
Example: Used during unboxing

static Character valueOf(char c)

Use: Returns Character object for a given char
Note: Uses internal caching for better performance

String toString()

Use: Converts Character object to String

static String toString(char c)

Use: Converts primitive char to String

boolean equals(Object obj)

Use: Compares two Character objects

int compareTo(Character another)

Use: Compares two characters numerically

static int compare(char x, char y)

Use: Compares two primitive char values

2. Character Type Checking Methods

static boolean isLetter(char ch)

Use: Checks if character is a letter (Unicode supported)

static boolean isDigit(char ch)

Use: Checks if character is a digit (0–9)

static boolean isLetterOrDigit(char ch)

Use: Validates alphanumeric characters

---

static boolean isLowerCase(char ch)

Use: Checks for lowercase letters

---

static boolean isUpperCase(char ch)

Use: Checks for uppercase letters

---

static boolean isWhitespace(char ch)

Use: Checks spaces, tabs, newlines

---

static boolean isSpaceChar(char ch)

Use: Checks Unicode space characters

---

static boolean isISOControl(char ch)

Use: Detects ISO control characters

---

static boolean isTitleCase(char ch)

Use: Checks title‑case characters (Unicode)

---

static boolean isJavaIdentifierStart(char ch)

Use: Validates start of Java variable name

---

static boolean isJavaIdentifierPart(char ch)

Use: Validates remaining variable name characters

---

3. Case Conversion Methods

static char toLowerCase(char ch)

Use: Converts character to lowercase

---

static char toUpperCase(char ch)

Use: Converts character to uppercase

---

static char toTitleCase(char ch)

Use: Converts character to title case

---

4. Numeric & Unicode Methods

static int getNumericValue(char ch)

Use: Returns numeric value of Unicode character
Example: 'A' → 10, '9' → 9

---

static int getType(char ch)

Use: Returns Unicode general category

---

static String getName(int codePoint)

Use: Returns Unicode name of character

---

5. Unicode Code Point Methods (Advanced / Interview Favorite)

static int charCount(int codePoint)

Use: Returns number of char values needed

---

static int codePointAt(char[] array, int index)

Use: Gets Unicode code point at index

---

static int codePointBefore(char[] array, int index)

Use: Gets Unicode code point before index

---

static int codePointCount(char[] array, int offset, int count)

Use: Counts Unicode code points

---

6. Digit Conversion Methods

static char forDigit(int digit, int radix)

Use: Converts number to character
Example: forDigit(10,16) → 'a'

---

static int digit(char ch, int radix)

Use: Converts character to numeric digit

7. Emoji & Supplementary (Java 8+)

static boolean isEmoji(char ch)

Use: Checks if character is emoji

✅ Interview Summary (Quick Recall)

Category	Examples
Validation	isDigit(), isLetter()
Case Conversion	toUpperCase(), toLowerCase()
Unicode	codePointAt(), charCount()
Java Identifiers	isJavaIdentifierStart()
Numeric	getNumericValue(), forDigit()

package com.softwaretestingo.sto00403_datatypes.character;
public class CharacterMethodsDemo 
{
    public static void main(String[] args) 
    {
        basicObjectMethods();
        propertyChecks();
        caseConversions();
        numericAndUnicodeInfo();
        codePointOps();
        digitRadixOps();
        javaIdentifierChecks();

        // Java 21+ emoji APIs (only compile/run on JDK 21+)
        emojiApisJava21Plus();
    }

    // ------------------------------------------------------------
    // 1) Character value & object-related methods
    // ------------------------------------------------------------
    static void basicObjectMethods() 
    {
        System.out.println("\n=== 1) Object/Value Methods ===");

        Character obj = Character.valueOf('A');
        char primitive = obj.charValue();
        System.out.println("charValue(): " + primitive);

        Character cached = Character.valueOf('A');
        System.out.println("valueOf('A'): " + cached);

        System.out.println("Character.toString('Z'): " + Character.toString('Z'));
        System.out.println("obj.toString(): " + obj.toString());

        System.out.println("equals(): " + obj.equals(Character.valueOf('A')));
        System.out.println("compareTo(): " + obj.compareTo(Character.valueOf('B')));
        System.out.println("compare('a','b'): " + Character.compare('a', 'b'));
    }

    // ------------------------------------------------------------
    // 2) Common character property checks
    // ------------------------------------------------------------
    static void propertyChecks() 
    {
        System.out.println("\n=== 2) Property Checks ===");

        char a = 'a';
        char A = 'A';
        char nine = '9';
        char space = ' ';
        char tab = '\t';

        System.out.println("isLetter('A'): " + Character.isLetter(A));
        System.out.println("isDigit('9'): " + Character.isDigit(nine));
        System.out.println("isLetterOrDigit('9'): " + Character.isLetterOrDigit(nine));

        System.out.println("isLowerCase('a'): " + Character.isLowerCase(a));
        System.out.println("isUpperCase('A'): " + Character.isUpperCase(A));

        System.out.println("isWhitespace(' '): " + Character.isWhitespace(space));
        System.out.println("isWhitespace('\\t'): " + Character.isWhitespace(tab));

        System.out.println("isSpaceChar(' '): " + Character.isSpaceChar(space));
        System.out.println("isISOControl('\\u0007'): " + Character.isISOControl('\u0007'));

        // Title case examples exist in Unicode; simple demo:
        System.out.println("isTitleCase('Dž'): " + Character.isTitleCase('Dž'));
    }

    // ------------------------------------------------------------
    // 3) Case conversions
    // ------------------------------------------------------------
    static void caseConversions()
    {
        System.out.println("\n=== 3) Case Conversions ===");

        System.out.println("toUpperCase('b'): " + Character.toUpperCase('b'));
        System.out.println("toLowerCase('C'): " + Character.toLowerCase('C'));
        System.out.println("toTitleCase('dž'): " + Character.toTitleCase('dž'));
    }

    // ------------------------------------------------------------
    // 4) Numeric + Unicode type/name
    // ------------------------------------------------------------
    static void numericAndUnicodeInfo() 
    {
        System.out.println("\n=== 4) Numeric + Unicode Info ===");

        System.out.println("getNumericValue('9'): " + Character.getNumericValue('9'));
        System.out.println("getNumericValue('A'): " + Character.getNumericValue('A'));

        System.out.println("getType('A'): " + Character.getType('A'));            

        // getName takes a codePoint int:
        int cp = 'A';
        System.out.println("getName('A' codePoint): " + Character.getName(cp));
    }

    // ------------------------------------------------------------
    // 5) Code point operations (important for Unicode/surrogates)
    // ------------------------------------------------------------
    static void codePointOps() 
    {
        System.out.println("\n=== 5) Code Point Operations ===");

        // String containing a supplementary character (emoji) uses surrogate pair in UTF-16:
        String s = "Hi \uD83D\uDE04"; // 😄 as surrogate pair
        int idx = 3; // position of surrogate start
        int codePointAt = s.codePointAt(idx);
        System.out.println("codePointAt(\"Hi 😄\", 3): " + codePointAt);

        System.out.println("charCount(codePointAt): " + Character.charCount(codePointAt));

        // Arrays:
        char[] arr = s.toCharArray();
        System.out.println("codePointAt(char[], index): " + Character.codePointAt(arr, idx));
        System.out.println("codePointBefore(char[], index): " + Character.codePointBefore(arr, idx + 2));

        // Count code points in a range:
        System.out.println("codePointCount(char[], 0, len): " + Character.codePointCount(arr, 0, arr.length));
    }

    // ------------------------------------------------------------
    // 6) Digit/radix conversion
    // ------------------------------------------------------------
    static void digitRadixOps() 
    {
        System.out.println("\n=== 6) Digit/Radix Operations ===");

        System.out.println("forDigit(10,16): " + Character.forDigit(10, 16));
        System.out.println("digit('F',16): " + Character.digit('F', 16));
        System.out.println("digit('8',10): " + Character.digit('8', 10));
    }

    // ------------------------------------------------------------
    // 7) Java identifier checks (variable name validation)
    // ------------------------------------------------------------
    static void javaIdentifierChecks() 
    {
        System.out.println("\n=== 7) Java Identifier Checks ===");

        char start = '_';
        char part = '9';
        System.out.println("isJavaIdentifierStart('_'): " + Character.isJavaIdentifierStart(start));
        System.out.println("isJavaIdentifierPart('9'): " + Character.isJavaIdentifierPart(part));
        // Oracle notes these methods have strict Unicode version rules for Java identifiers.
    }

    // ------------------------------------------------------------
    // 8) Emoji APIs (Java 21+)
    // ------------------------------------------------------------
    static void emojiApisJava21Plus() 
    {
        System.out.println("\n=== 8) Emoji APIs (Java 21+) ===");
        // Java 21 introduced six emoji-related methods in Character.

        String msg = "Hey Java! ☕️ 😄 123";
        //boolean hasEmoji = msg.codePoints().anyMatch(Character::isEmoji);
        //boolean hasEmojiPresentation = msg.codePoints().anyMatch(Character::isEmojiPresentation);

        //System.out.println("contains isEmoji: " + hasEmoji);
        //System.out.println("contains isEmojiPresentation: " + hasEmojiPresentation);

        // Why check isEmojiPresentation?
        // Digits 0-9 can be treated as Emoji by isEmoji(), so isEmojiPresentation is often closer to what users expect.

        // Other emoji-related checks (Java 21+):
        //int firstEmoji = msg.codePoints().filter(Character::isEmoji).findFirst().orElse(-1);
        //if (firstEmoji != -1) 
        //{
            //System.out.println("isEmojiModifier(firstEmoji): " + Character.isEmojiModifier(firstEmoji));
           // System.out.println("isEmojiModifierBase(firstEmoji): " + Character.isEmojiModifierBase(firstEmoji));
          //  System.out.println("isEmojiComponent(firstEmoji): " + Character.isEmojiComponent(firstEmoji));
            //System.out.println("isExtendedPictographic(firstEmoji): " + Character.isExtendedPictographic(firstEmoji));
       // }
    }
}

 Output:

=== 1) Object/Value Methods ===
charValue(): A
valueOf('A'): A
Character.toString('Z'): Z
obj.toString(): A
equals(): true
compareTo(): -1
compare('a','b'): -1

=== 2) Property Checks ===
isLetter('A'): true
isDigit('9'): true
isLetterOrDigit('9'): true
isLowerCase('a'): true
isUpperCase('A'): true
isWhitespace(' '): true
isWhitespace('\t'): true
isSpaceChar(' '): true
isISOControl('\u0007'): true
isTitleCase('Dž'): true

=== 3) Case Conversions ===
toUpperCase('b'): B
toLowerCase('C'): c
toTitleCase('dž'): Dž

=== 4) Numeric + Unicode Info ===
getNumericValue('9'): 9
getNumericValue('A'): 10
getType('A'): 1
getName('A' codePoint): LATIN CAPITAL LETTER A

=== 5) Code Point Operations ===
codePointAt("Hi 😄", 3): 128516
charCount(codePointAt): 2
codePointAt(char[], index): 128516
codePointBefore(char[], index): 128516
codePointCount(char[], 0, len): 4

=== 6) Digit/Radix Operations ===
forDigit(10,16): a
digit('F',16): 15
digit('8',10): 8

=== 7) Java Identifier Checks ===
isJavaIdentifierStart('_'): true
isJavaIdentifierPart('9'): true

=== 8) Emoji APIs (Java 21+) ===

From real project usage (parsing, validation, normalization, Unicode-safe processing), these are the most common:

✅ Very commonly used (daily life)

• isDigit() — number checks in input parsing
• isLetter() — alpha validation
• isLetterOrDigit() — username/token validation
• isWhitespace() — trimming/format handling
• toUpperCase() / toLowerCase() — normalization
• valueOf() / toString() — conversions and boxing/unboxing patterns
• compare() / compareTo() — sorting/ordering chars

✅ Common when you handle Unicode beyond ASCII (important for senior interviews)

• codePointAt(), charCount(), codePointCount() — Unicode-safe iteration
• getNumericValue() — numeric meaning across Unicode digits/letters
• isJavaIdentifierStart()/Part() — token/identifier rules