Expand Authors Top

If you have a few years of experience in the Java ecosystem and you’d like to share that with the community, have a look at our Contribution Guidelines.

November Discount Launch 2022 – Top
We’re finally running a Black Friday launch. All Courses are 30% off until next Friday:

>> GET ACCESS NOW

November Discount Launch 2022 – TEMP TOP (NPI)
We’re finally running a Black Friday launch. All Courses are 30% off until next Friday:

>> GET ACCESS NOW

Expanded Audience – Frontegg – Security (partner)
announcement - icon User management is very complex, when implemented properly. No surprise here.

Not having to roll all of that out manually, but instead integrating a mature, fully-fledged solution - yeah, that makes a lot of sense.
That's basically what Frontegg is - User Management for your application. It's focused on making your app scalable, secure and enjoyable for your users.
From signup to authentication, it supports simple scenarios all the way to complex and custom application logic.

Have a look:

>> Elegant User Management, Tailor-made for B2B SaaS

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'substring() Method

The String class comes with a handy method called substringAs 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.12.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.

As always, the code used in this article can be found over on GitHub.

November Discount Launch 2022 – Bottom
We’re finally running a Black Friday launch. All Courses are 30% off until next Friday:

>> GET ACCESS NOW

Generic footer banner
Comments are closed on this article!