How to Truncate a String in Java

1. Overview

In this tutorial, we’ll learn multiple ways to truncate a String to a desired number of characters in Java.

We’ll start by exploring ways to do this using the JDK itself. Then we’ll look at how to do this using some popular third-party libraries.

2. Truncating a String Using the JDK

Java provides a number of convenient ways to truncate a String. Let’s take a look.

2.1. Using String’s substring() Method

The String class comes with a handy method called substring. As the name indicates, substring() returns the portion of a given String between the specified indexes.

Let’s see it in action:

static String usingSubstringMethod(String text, int length) {
    if (text.length() <= length) {
        return text;
    } else {
        return text.substring(0, length);
    }
}

In the above example, if the specified length is greater than the length of text, we return text itself. This is because passing to substring() a length greater than the number of characters in the String results in an IndexOutOfBoundsException.

Otherwise, we return the substring that begins at the index zero and extends to – but does not include – the character at the index length.

Let’s confirm this using a test case:

static final String TEXT = "Welcome to baeldung.com";

@Test
public void givenStringAndLength_whenUsingSubstringMethod_thenTrim() {

    assertEquals(TrimStringOnLength.usingSubstringMethod(TEXT, 10), "Welcome to");
}

As we can see, the start index is inclusive and the end index is exclusive. Thus, the character at the index length will not be included in the returned substring.

2.2. Using String’s split() Method

Another way to truncate a String is to use the split() method, which uses a regular expression to split the String into pieces.

Here we’ll use a regular expression feature called positive lookbehind to match the specified number of characters beginning at the start of the String:

static String usingSplitMethod(String text, int length) {

    String[] results = text.split("(?<=\\G.{" + length + "})");

    return results[0];
}

The first element of results will either be our truncated String, or the original String if length was longer than text.

Let’s test our method:

@Test
public void givenStringAndLength_whenUsingSplitMethod_thenTrim() {

    assertEquals(TrimStringOnLength.usingSplitMethod(TEXT, 13), "Welcome to ba");
}

2.3. Using the Pattern Class

Similarly, we can use the Pattern class to compile a regular expression that matches the start of the String up to a specified number of characters.

For instance, let’s use {1,” + length + “}. This regex matches at least one and at most length characters:

static String usingPattern(String text, int length) {

    Optional<String> result = Pattern.compile(".{1," + length + "}")
      .matcher(text)
      .results()
      .map(MatchResult::group)
      .findFirst();

    return result.isPresent() ? result.get() : EMPTY;

}

As we can see above, after compiling our regular expression into a Pattern, we can use Pattern’s matcher() method to interpret our String according to that regex. We’re then able to group the results and return the first one, which is our truncated String.

Now let’s add a test case to verify that our code works as expected:

@Test
public void givenStringAndLength_whenUsingPattern_thenTrim() {

    assertEquals(TrimStringOnLength.usingPattern(TEXT, 19), "Welcome to baeldung");
}

2.4. Using CharSequence’s codePoints() Method

Java 9 provides a codePoints() method to convert a String into a stream of code point values.

Let’s see how we can use this method combined with the stream API to truncate a string:

static String usingCodePointsMethod(String text, int length) {

    return text.codePoints()
      .limit(length)
      .collect(StringBuilder::new, StringBuilder::appendCodePoint, StringBuilder::append)
      .toString();
}

Here, we used the limit() method to limit the Stream to the given length. Then we used the StringBuilder to build our truncated string.

Next, let’s verify that our method works:

@Test
public void givenStringAndLength_whenUsingCodePointsMethod_thenTrim() {

    assertEquals(TrimStringOnLength.usingCodePointsMethod(TEXT, 6), "Welcom");
}

3. Apache Commons Library

The Apache Commons Lang library includes a StringUtils class for manipulating Strings.

First, let’s add the Apache Commons dependency to our pom.xml:

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

3.1. Using StringUtils’s left() Method

StringUtils has a useful static method called left(). StringUtils.left() returns the specified number of leftmost characters of a String in a null-safe manner:

static String usingLeftMethod(String text, int length) {

    return StringUtils.left(text, length);
}

3.2. Using StringUtils’s truncate() Method

Alternatively, we can use StringUtils.truncate() to accomplish the same goal:

public static String usingTruncateMethod(String text, int length) {

    return StringUtils.truncate(text, length);
}

4. Guava Library

In addition to using core Java methods and the Apache Commons library to truncate a String, we can also use Guava. Let’s begin by adding the Guava dependency to our pom.xml file:

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

Now we can use Guava’s Splitter class to truncate our String:

static String usingSplitter(String text, int length) {
    
    Iterable<String> parts = Splitter.fixedLength(length)
      .split(text);

    return parts.iterator()
      .next();
}

We used Splitter.fixedLength() to split our String into multiple pieces of the given length. Then, we returned the first element of the result.

5. Conclusion

In this article, we learned a variety of ways to truncate a String to a particular number of characters in Java.

We looked at some ways to do this using the JDK. Then we truncated Strings using a couple of third-party libraries.