Get First n Characters in a String in Java

1. Overview

In this short tutorial, we’ll explore different ways of getting the first n characters of a string in Java.

First, we’ll learn how to do this using core JDK methods and classes. Then, we’ll see how to achieve the same outcome using external libraries such as Apache Commons Lang and Guava.

2. Using Core JDK

JDK provides several methods that we can use to get the first n characters of a given string. So, let’s take a close look at each option.

2.1. Using String#substring Method

The substring() method belongs to the String class and offers the easiest solution to answer our central question. As the name implies, this method returns as a new string a subset of the given string.

So, let’s see it in action:

@Test
void givenString_whenUsingSubstringMethod_thenGetFirstChars() {
    String givenInput = "Hello Baeldung Readers";

    assertEquals("He", givenInput.substring(0, 2));
}

The method accepts two arguments, beginIndex and endIndex. beginIndex denotes the index of the first character and endIndex represents the last index which is exclusive.

With that being said, the returned substring starts at the specified endIndex and extends to the character at the index endIndex – 1.

2.2. Using String#subSequence Method

Another solution would be to use the subSequence() method. It returns a CharSequence object that holds a portion of the specified string.

The invocation of subSequence(start, end) behaves exactly like the invocation of the substring(start, end) method. So, let’s see it in action:

@Test
void givenString_whenUsingSubSequenceMethod_thenGetFirstChars() {
    String givenInput = "Welcome";

    assertEquals("Wel", givenInput.subSequence(0, 3));
}

Similarly, the method returns the first three characters “Wel” of the string “Welcome”. We should remember that this method throws IndexOutOfBoundsException if beginIndex or endIndex is negative, or if endIndex is greater than the string length, or when beginIndex is greater than endIndex.

2.3. Using String#chars Method

The String class provides the chars() as another option to retrieve the first n characters. This new method is introduced in Java 9 to manipulate a given string as a Stream.

So, let’s exemplify the use of the chars() method using another test case:

@Test
void givenString_whenUsingStreamApi_thenGetFirstChars() {
    String givenInput = "The world is beautiful";
    String result = givenInput.chars()
      .limit(3)
      .collect(StringBuilder::new, StringBuilder::appendCodePoint, StringBuilder::append)
      .toString();

    assertEquals("The", result);
}

In a nutshell, chars() returns an IntStream holding the char values of the string input. Furthermore, we used the limit(3) method to retrieve the first three values. Then, we used collect() with StringBuilder to build a string from the returned values.

3. Using Apache Commons Lang

Alternatively, we can use the Apache Commons Lang library to tackle our challenge. It comes with a set of utility classes, such as StringUtils, that we can use to perform string operations.

First, let’s add its dependency to the pom.xml file:

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.14.0</version>
</dependency>

3.1. Using StringUtils#substring Method

Typically, StringUtils provides its version of the substring() method. The particularity of this method is that it’s null-safe compared to String#substring:

@Test
void givenString_whenUsingStringUtilsSubstringMethod_thenGetFirstChars() {
    String givenInput = "Baeldung";

    assertEquals("Baeld", StringUtils.substring(givenInput, 0, 5));
}

As shown above, the returned substring “Baeld” starts with the character in the position zero and ends before the  position 5.

3.2. Using StringUtils#left Method

Similarly, we can use the left() method to accomplish the same outcome. This method returns the leftmost n characters of the given string.

So, let’s illustrate how to use StringUtils#left using a practical example:

@Test
void givenString_whenUsingStringUtilsLeftMethod_thenGetFirstChars() {
    String givenInput = "kindness always wins";

    assertEquals("kind", StringUtils.left(givenInput, 4));
}

The good thing about this method is that it’s null-safe as it returns null if the specified string input is null.

4. Using Guava

Another solution would be using the Guava. As usual, before starting to work with this library, we need to add its dependency to pom.xml:

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>33.0.0-jre</version>
</dependency>

Guava provides the Ascii#truncate method that we can use as a workaround to get the first characters of a string:

@Test
void givenString_whenUsingGuavaTruncateMethod_thenGetFirstChars() {
    String givenInput = "Tamassint";

    assertEquals("Tama", Ascii.truncate(givenInput, 4, ""));
}

In short, this method truncates the given string to the specified maximum length of 4 in our case.

5. Conclusion

In this short article, we explored various ways of getting the first n characters of a given string in Java.

Along the way, we saw how to use JDK methods and classes. Then, we learned how to achieve the same objective using external libraries such as Apache Commons Lang and Guava.