Getting a Character by Index From a String in Java

1. Introduction

Sometimes we need to work with the individual characters of a String rather than the String as a whole. For example, we often want to extract the character at a given position of a String.

In this tutorial, we’ll explore several approaches to achieve the goal.

2. The charAt() Method

Let’s take a look at the method signature from the String class:

public char charAt(int index) {...}

The charAt() method returns the char at the index specified in the input parameter. The index ranges from 0 (the first character) to the total length of the String – 1 (the last character).

Now, let’s see an example:

String sample = "abcdefg";
Assert.assertEquals('d', sample.charAt(3));

In this case, the result was the fourth character of the String – the character “d”.

As we can see, we must pass charAt() the index of the character we want. Next, let’s figure out what will happen if we pass charAt() an index out of the valid range:

String sample = "abcdefg";
assertThrows(StringIndexOutOfBoundsException.class, () -> sample.charAt(-1));
assertThrows(StringIndexOutOfBoundsException.class, () -> sample.charAt(sample.length()));

The charAt() method throws a StringIndexOutOfBoundsException if the parameter index is negative or if it’s equal to or greater than the length of the String.

3. The toCharArray() Method

Another way to access characters in a String is by converting the entire String into a character array using toCharArray(). Once we have the array, we can use the familiar array indexing to retrieve the character at a specific position:

String sample = "abcdefg";
char[] chars = sample.toCharArray();
assertEquals('d', chars[3]);
assertEquals('f', chars[5]);

As the example shows, this approach is handy if we plan to perform array-style operations.

4. The codePointAt() Method

Besides charAt() and toCharArray(), Java also provides the codePointAt(int index) method. This method returns the Unicode code point at the specified index. A code point is an integer representing a Unicode character.

String sample = "abcdefg";
char[] chars = sample.toCharArray();
assertEquals('d', sample.codePointAt(3));
assertEquals('f', sample.codePointAt(5));

String emojiString = "😊"; // '😊' is Unicode char: U+1F60A
assertEquals(0x1F60A, emojiString.codePointAt(0));

As we can see, unlike charAt(), which returns a single 16‑bit char, codePointAt() correctly handles supplementary characters that require two char values, such as emoji or rare symbols.

5. The getChars() Method

Another way to access characters from a String is by using the getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) method. This method copies a range of characters from the String into a destination character array.

Next, let’s see an example:

String sample = "abcdefg";
char[] singleTargetChar = new char[1];
sample.getChars(3, 3 + 1, singleTargetChar, 0);
assertEquals('d', singleTargetChar[0]);
 
char[] multiTargetChars = new char[3];
sample.getChars(3, 3 + 3, multiTargetChars, 0);
assertArrayEquals(new char[] { 'd', 'e', 'f' }, multiTargetChars);

As the example shows, we can use getChars() to efficiently extract a single character or a subset of characters from an input String.

6. Using the Stream API

Additionally, with Java 8, we can leverage the Streams API to process Strings in a functional style. Let’s first look at how Stream API solves this problem:

char getCharUsingStream(String str, int index) {
    return str.chars()
      .mapToObj(ch -> (char) ch)
      .toArray(Character[]::new)[index];
}

Now, let’s understand how this method works:

• str.chars() – Produces an IntStream object
• maptoObj(ch -> (char) ch) – Converts the IntStream to a Stream<Character>
• toArray(Character[]::new)[index] – Convert Stream<Character> into an Character[] array and get the element at the specific index

Finally, let’s test if this method works as expected:

String sample = "abcdefg";
assertEquals('d', getCharUsingStream(sample, 3));
assertEquals('f', getCharUsingStream(sample, 5));
assertThrows(ArrayIndexOutOfBoundsException.class, () -> getCharUsingStream(sample, 100));

It’s worth mentioning that if we pass an invalid index to our getCharUsingStream() method, it throws an ArrayIndexOutOfBoundsException instead of a StringIndexOutOfBoundsException. This is because we converted the input String into an array in our stream pipeline.

7. Get Character as a String

We have explored different approaches to get a character at a specific index from a String. All these approaches return a char. However, sometimes, we would like to have a String instead of a char.

There are different ways to convert the char result to a String, for example, using Character.toString() and String.valueOf().

Let’s take the charAt() approach as an example to show how these two methods perform the conversion:

String sample = "abcdefg";
assertEquals("d", Character.toString(sample.charAt(3)));
assertEquals("d", String.valueOf(sample.charAt(3)));

As the example shows, both Character.toString() and String.valueOf() do the job effectively. In fact, Character.toString() internally calls String.valueOf():

public static String toString(char c) {
    return String.valueOf(c);
}

Therefore, we can use whichever feels more natural.

8. Conclusion

In this article, we explored different ways to get a character at a given position of a String. We also discussed how to convert a char to a String quickly.