Java String codePointCount() Method

What You’ll Learn

The codePointCount() method counts how many Unicode code points appear in a slice of a string. Unlike length(), it treats emoji and other supplementary characters as a single symbol—essential for accurate text limits and validation.

Definition and Usage

In Java, codePointCount(int beginIndex, int endIndex) belongs to java.lang.String. It answers the question: “How many Unicode characters (code points) lie between these two indexes?” The indexes themselves refer to UTF-16 code unit positions, the same numbering used by charAt() and substring().

The range follows Java’s usual half-open convention: include the code point at beginIndex, exclude whatever starts at endIndex. Calling codePointCount(0, str.length()) counts every visible character in the entire string.

📝 Syntax

The codePointCount() method is declared in the String class:

public int codePointCount(int beginIndex, int endIndex)

Parameters

• beginIndex — the starting index (inclusive). Must be between 0 and length().
• endIndex — the ending index (exclusive). Must be between beginIndex and length().

Return Value

Returns the number of Unicode code points in the range [beginIndex, endIndex).

Exceptions

Throws StringIndexOutOfBoundsException if beginIndex is negative, greater than endIndex, or greater than the string length; or if endIndex is negative or greater than the string length.

Examples Gallery

Run these in Java 8+. They progress from a simple full-string count to emoji-aware ranges and comparison with length().

public class CodePointCountExample {
    public static void main(String[] args) {
        String str = "Java\uD83D\uDE80Programming";

        int codePoints = str.codePointCount(0, str.length());
        int charUnits  = str.length();

        System.out.println("Code points (entire string): " + codePoints);
        System.out.println("UTF-16 length():           " + charUnits);
    }
}

Code points (entire string): 16
UTF-16 length():           17

public class EmojiCount {
    public static void main(String[] args) {
        String greeting = "Hi 😀";

        System.out.println("Visible characters: " +
            greeting.codePointCount(0, greeting.length()));
        System.out.println("length() returns:   " + greeting.length());
    }
}

Visible characters: 4
length() returns:   5

public class PartialRangeCount {
    public static void main(String[] args) {
        String str = "Java\uD83D\uDE80Programming";

        int full   = str.codePointCount(0, str.length());
        int partial = str.codePointCount(5, str.length());

        System.out.println("Full string:  " + full + " code points");
        System.out.println("From index 5: " + partial + " code points");
    }
}

Full string:  16 code points
From index 5: 12 code points

public class AsciiRangeCount {
    public static void main(String[] args) {
        String word = "Programming";
        int begin = 0;
        int end   = 4;

        int cpCount  = word.codePointCount(begin, end);
        int charDiff = end - begin;

        System.out.println("codePointCount(0, 4): " + cpCount);
        System.out.println("end - begin:          " + charDiff);
        System.out.println("Substring: \"" + word.substring(begin, end) + "\"");
    }
}

codePointCount(0, 4): 4
end - begin:          4
Substring: "Prog"

public class InputLimitCheck {
    private static final int MAX_CODE_POINTS = 10;

    public static boolean isWithinLimit(String input) {
        if (input == null) return true;
        return input.codePointCount(0, input.length()) <= MAX_CODE_POINTS;
    }

    public static void main(String[] args) {
        System.out.println(isWithinLimit("Hello"));       // true
        System.out.println(isWithinLimit("1234567890"));  // true
        System.out.println(isWithinLimit("12345678901")); // false
        System.out.println(isWithinLimit("Hi 😀😀😀"));     // true (6 visible)
    }
}

true
true
false
true

🚀 Common Use Cases

• Input validation — enforce “max 280 characters” style limits that match visible symbols.
• Substring planning — know how many real characters a char-index range covers before slicing.
• Internationalization — count user-visible glyphs in multilingual forms and chat apps.
• Progress indicators — show “12 of 50 characters” accurately when emoji are allowed.
• Testing Unicode handling — verify that parsers treat supplementary characters as single units.

📝 Notes

• The range is half-open: include beginIndex, exclude endIndex—same as substring(beginIndex, endIndex).
• When beginIndex == endIndex, the result is 0 (empty range).
• Surrogate pairs count as one code point, not two.
• Indexes refer to UTF-16 code units, not bytes in a file or network buffer.
• In Java 8+, str.codePoints().count() counts all code points in the full string as an alternative API.

⚡ Optimization

codePointCount() scans the specified range once (O(endIndex - beginIndex)). For a one-time full-string count, it is efficient and clearer than manual loops. If you already iterate code points with codePoints() or need repeated counts on huge strings, profile before optimizing—for typical form validation and UI limits, this method is the right balance of correctness and simplicity.

💡 Best Practices