Java String codePointBefore() Method

What You’ll Learn

The codePointBefore() method returns the Unicode code point that appears immediately before a given index. It is the backward-looking companion to codePointAt() and is essential when you walk a string from right to left or need the character just left of a cursor position.

Definition and Usage

In Java, codePointBefore(int index) is defined on java.lang.String. Picture each index as a gap between characters: index 0 is before the first character, index 1 is between the first and second, and so on. The method returns the code point of the character to the left of that gap.

For the string "Java", codePointBefore(1) returns the code point for 'J' (74), and codePointBefore(4) returns 'a' (97) because index 4 sits at the end of the word, immediately after the final letter.

📝 Syntax

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

public int codePointBefore(int index)

Parameters

• index — the position after the character you want. Must be between 1 and length() inclusive.

Return Value

Returns the Unicode code point (as an int) of the character that ends immediately before the given index.

Exceptions

Throws StringIndexOutOfBoundsException if index is less than 1 or greater than the string length.

Examples Gallery

These programs run in Java 8+. They show basic lookups, emoji handling, comparison with codePointAt(), and safe backward iteration.

public class CodePointBeforeExample {
    public static void main(String[] args) {
        String text = "Java";

        int first = text.codePointBefore(1);
        int last  = text.codePointBefore(text.length());

        System.out.println("Before index 1: " + first + " ('" + (char) first + "')");
        System.out.println("Before end:     " + last  + " ('" + (char) last  + "')");
    }
}

Before index 1: 74 ('J')
Before end:     97 ('a')

public class BeforeMiddleIndex {
    public static void main(String[] args) {
        String str = "Hello, Java!";
        int index = 7;

        int cp = str.codePointBefore(index);

        System.out.println("Code point before index " + index + ": " + cp);
        System.out.println("Character: '" + (char) cp + "'");
    }
}

Code point before index 7: 32
Character: ' '

public class EmojiBefore {
    public static void main(String[] args) {
        String text = "Java\uD83D\uDE00"; // "Java" + grinning face emoji

        System.out.println("Length: " + text.length());
        System.out.println("Before index 4: " + text.codePointBefore(4)
            + " ('" + (char) text.codePointBefore(4) + "')");
        System.out.println("Before index 6: " + text.codePointBefore(6)
            + " (U+" + Integer.toHexString(text.codePointBefore(6)).toUpperCase() + ")");
    }
}

Length: 6
Before index 4: 97 ('a')
Before index 6: 128512 (U+1F600)

public class BeforeVsAt {
    public static void main(String[] args) {
        String word = "Code";
        int index = 2;

        int before = word.codePointBefore(index);
        int at     = word.codePointAt(index);

        System.out.println("codePointBefore(" + index + "): " + before
            + " ('" + (char) before + "')");
        System.out.println("codePointAt(" + index + "):     " + at
            + " ('" + (char) at + "')");
    }
}

codePointBefore(2): 67 ('C')
codePointAt(2):     111 ('o')

public class ReverseCodePoints {
    public static void main(String[] args) {
        String text = "Go😀";

        for (int i = text.length(); i > 0; ) {
            int cp = text.codePointBefore(i);
            System.out.println("Before index " + i + ": " + cp);
            i -= Character.charCount(cp);
        }
    }
}

Before index 5: 128512
Before index 3: 111
Before index 2: 71

🚀 Common Use Cases

• Reverse parsing — read tokens or digits from the end of a string toward the start.
• Text editor logic — find the character immediately left of a caret (cursor) position.
• Backspace simulation — determine which code point would be deleted when the user presses Backspace.
• International text — move backward through emoji and non-BMP characters without splitting surrogate pairs.
• Pairing with codePointAt() — inspect characters on both sides of a split or delimiter index.

📝 Notes

• Valid indexes are 1 through length(), unlike charAt() which starts at 0.
• codePointBefore(0) is always invalid—there is no character before the beginning.
• The index refers to UTF-16 code unit positions, not byte offsets in a file.
• Supplementary characters (emoji, rare scripts) are handled correctly by checking surrogate pairs backward.
• Throws StringIndexOutOfBoundsException (not a generic IndexOutOfBoundsException message you must guess from).

⚡ Optimization

codePointBefore() runs in constant time (O(1)) for a single lookup. For scanning an entire string backward, pair it with Character.charCount() rather than decrementing by 1 each time. For bulk forward processing, prefer codePoints() or a forward loop with codePointAt(). No special optimization is needed for occasional backward reads.

💡 Best Practices