Java Character Class — Locale Pitfalls in Validation

public class CharVsCharacter {
    public static void main(String[] args) {

        // Primitive char — just a raw value, no methods attached
        char firstInitial = 'J';

        // Character wrapper — an object that boxes the same value
        Character wrappedInitial = 'J';  // auto-boxing happens here automatically

        // Auto-unboxing: Java silently converts Character -> char when needed
        char unboxed = wrappedInitial;   // no cast required

        System.out.println("Primitive char  : " + firstInitial);
        System.out.println("Character object: " + wrappedInitial);
        System.out.println("Unboxed back    : " + unboxed);

        // The numeric value Java stores internally for 'J' is 74 (Unicode code point)
        System.out.println("Numeric value of 'J': " + (int) firstInitial);

        // Comparing char primitives uses == safely (they're just numbers)
        System.out.println("firstInitial == 'J': " + (firstInitial == 'J'));

        // Comparing Character objects should use .equals(), not ==
        Character anotherWrapped = 'J';
        System.out.println("Equals comparison  : " + wrappedInitial.equals(anotherWrapped));
    }
}

public class CharacterMethodsDemo {
    public static void main(String[] args) {

        char letterA      = 'A';
        char digitFive    = '5';
        char spaceChar    = ' ';
        char dollarSign   = '$';
        char lowercaseM   = 'm';

        // --- CLASSIFICATION METHODS ---

        // isLetter: true for alphabetic characters only
        System.out.println("isLetter('A')    : " + Character.isLetter(letterA));       // true
        System.out.println("isLetter('5')    : " + Character.isLetter(digitFive));     // false

        // isDigit: true for 0-9 only
        System.out.println("isDigit('5')     : " + Character.isDigit(digitFive));      // true
        System.out.println("isDigit('A')     : " + Character.isDigit(letterA));        // false

        // isLetterOrDigit: true for letters OR digits — great for alphanumeric checks
        System.out.println("isLetterOrDigit('$'): " + Character.isLetterOrDigit(dollarSign)); // false

        // isWhitespace: catches space, tab ('\t'), and newline ('\n')
        System.out.println("isWhitespace(' '): " + Character.isWhitespace(spaceChar)); // true

        // isUpperCase / isLowerCase
        System.out.println("isUpperCase('A') : " + Character.isUpperCase(letterA));    // true
        System.out.println("isLowerCase('m') : " + Character.isLowerCase(lowercaseM)); // true

        // --- TRANSFORMATION METHODS ---

        // toUpperCase and toLowerCase return a NEW char — nothing is mutated
        char upperM = Character.toUpperCase(lowercaseM);
        System.out.println("toUpperCase('m') : " + upperM);                            // M

        char lowerA = Character.toLowerCase(letterA);
        System.out.println("toLowerCase('A') : " + lowerA);                            // a

        // --- GOTCHA: casting vs getNumericValue ---
        char digitSeven = '7';

        // WRONG way to get the integer 7 from the character '7'
        int unicodePoint = (int) digitSeven;  // gives 55 — the Unicode code point, NOT 7!
        System.out.println("(int)'7' gives   : " + unicodePoint);                      // 55

        // CORRECT way: getNumericValue converts '7' -> 7 as expected
        int actualNumber = Character.getNumericValue(digitSeven);
        System.out.println("getNumericValue  : " + actualNumber);                      // 7
    }
}

public class PasswordValidator {

    /**
     * Validates a password against three rules:
     *  1. Must contain at least one uppercase letter
     *  2. Must contain at least one lowercase letter
     *  3. Must contain at least one digit
     */
    public static boolean isStrongPassword(String password) {

        boolean hasUppercase = false;  // flag: have we seen an uppercase letter yet?
        boolean hasLowercase = false;  // flag: have we seen a lowercase letter yet?
        boolean hasDigit     = false;  // flag: have we seen a digit yet?

        // Walk through every character in the password one at a time
        for (int i = 0; i < password.length(); i++) {

            char currentChar = password.charAt(i);  // pull out character at position i

            if (Character.isUpperCase(currentChar)) {
                hasUppercase = true;  // found an uppercase letter, flip the flag
            } else if (Character.isLowerCase(currentChar)) {
                hasLowercase = true;  // found a lowercase letter, flip the flag
            } else if (Character.isDigit(currentChar)) {
                hasDigit = true;      // found a digit, flip the flag
            }
        }

        // Password is strong only if ALL three conditions are met
        return hasUppercase && hasLowercase && hasDigit;
    }

    /**
     * Checks whether a given string contains only digit characters.
     * Useful for validating things like phone numbers or ZIP codes
     * before parsing them as integers.
     */
    public static boolean isAllDigits(String input) {
        if (input == null || input.isEmpty()) {
            return false;  // empty or null strings are never "all digits"
        }

        for (int i = 0; i < input.length(); i++) {
            if (!Character.isDigit(input.charAt(i))) {
                return false;  // bail out the moment we find a non-digit
            }
        }
        return true;
    }

    public static void main(String[] args) {

        String weakPassword   = "hello";          // all lowercase, no digit
        String mediumPassword = "Hello";           // upper + lower, no digit
        String strongPassword = "Hello7";          // upper + lower + digit — passes!
        String allUppers      = "HELLO7";          // upper + digit, no lowercase

        System.out.println("--- Password Strength Check ---");
        System.out.println(weakPassword   + " is strong: " + isStrongPassword(weakPassword));
        System.out.println(mediumPassword + " is strong: " + isStrongPassword(mediumPassword));
        System.out.println(strongPassword + " is strong: " + isStrongPassword(strongPassword));
        System.out.println(allUppers      + " is strong: " + isStrongPassword(allUppers));

        System.out.println();
        System.out.println("--- Digits-Only Check ---");
        System.out.println("\"90210\"  all digits: " + isAllDigits("90210"));
        System.out.println("\"45A78\"  all digits: " + isAllDigits("45A78"));
        System.out.println("\"\"      all digits: " + isAllDigits(""));
    }
}

public class UnicodeAwareness {
    public static void main(String[] args) {

        // Standard Latin character — fits comfortably in a char (code point 65 = 'A')
        char latinLetter = 'A';
        System.out.println("'A' isLetter (char version)       : " + Character.isLetter(latinLetter));

        // An emoji represented as a Unicode code point (U+1F600 = Grinning Face)
        // This does NOT fit in a single char — it needs the int codePoint version
        int grinningFaceCodePoint = 0x1F600;  // hexadecimal 1F600

        // The int-based overload handles supplementary characters correctly
        System.out.println("Emoji isLetter (codePoint version): " + Character.isLetter(grinningFaceCodePoint));
        System.out.println("Emoji type    (SURROGATE_PAIR = 4) : " + Character.getType(grinningFaceCodePoint));

        // Character.toString with a code point converts it to a displayable String
        // Note: requires Java 11+ for the single-argument codePoint overload
        // For broader compatibility, use new String(Character.toChars(codePoint))
        String emojiString = new String(Character.toChars(grinningFaceCodePoint));
        System.out.println("Emoji displayed                   : " + emojiString);

        // Everyday tip: for normal English/Latin text, char methods are perfectly fine
        String message = "Hello2025";
        System.out.println("\nCounting letters and digits in: " + message);
        int letterCount = 0;
        int digitCount  = 0;
        for (int i = 0; i < message.length(); i++) {
            char ch = message.charAt(i);
            if (Character.isLetter(ch)) letterCount++;
            else if (Character.isDigit(ch)) digitCount++;
        }
        System.out.println("Letters: " + letterCount + ", Digits: " + digitCount);
    }
}

public class CharPerformance {
    public static void main(String[] args) {
        // Simulate parsing a large file: 10 million characters
        int size = 10_000_000;

        // Primitive char array — just 2 bytes per element
        char[] charArray = new char[size];
        long start = System.nanoTime();
        for (int i = 0; i < size; i++) {
            charArray[i] = (char) ('A' + (i % 26));
        }
        long end = System.nanoTime();
        System.out.println("char[] assignment took " + (end - start) / 1_000_000 + " ms");

        // Character array — each element is an object
        Character[] charObjArray = new Character[size];
        start = System.nanoTime();
        for (int i = 0; i < size; i++) {
            // Auto-boxing occurs: each char is wrapped into a Character object
            charObjArray[i] = (char) ('A' + (i % 26));
        }
        end = System.nanoTime();
        System.out.println("Character[] assignment took " + (end - start) / 1_000_000 + " ms");

        // Note: for chars in 0-127, caching avoids new objects, but overhead still exists
        // Run with -Xmx512m to see GC effects
    }
}