How to Truncate a String in Java – 如何在Java中截断一个字符串

最后修改: 2022年 7月 13日

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

2.1.使用String’s substring() 方法

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";

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

2.2.使用String’s split() 方法

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:

这里我们将使用一个叫做positive lookbehind的正则表达式功能来匹配从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:


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.

同样,我们可以使用Pattern 类来编译一个regular expression,该表达式匹配String的开始部分,直至指定的字符数

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

例如,让我们使用 {1,” + length + “}。这个铰链至少匹配一个,最多匹配length字符。

static String usingPattern(String text, int length) {

    Optional<String> result = Pattern.compile(".{1," + length + "}")

    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:


public void givenStringAndLength_whenUsingPattern_thenTrim() {

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

2.4. Using CharSequence’s codePoints() Method

2.4.使用CharSequence/em>s codePoints()方法

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

Java 9提供了一个codePoints()方法来将String转换为码点值的流。

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

让我们看看如何使用这个方法与stream API相结合来截断一个字符串。

static String usingCodePointsMethod(String text, int length) {

    return text.codePoints()
      .collect(StringBuilder::new, StringBuilder::appendCodePoint, StringBuilder::append)

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:


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.

Apache Commons Lang库包括一个StringUtils类,用于操作Strings。

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

首先,让我们把Apache Commons的依赖性添加到我们的pom.xml


3.1. Using StringUtils’s left() Method

3.1.使用StringUtils的 left() 方法

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

3.2.使用StringUtilsstruncate() 方法

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:

除了使用核心Java方法和Apache Commons库来截断一个String之外,我们还可以使用Guava。让我们首先将Guava依赖添加到我们的pom.xml文件中。


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)

    return parts.iterator()

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

我们使用Splitter.fixedLength() 将我们的String分割成多个给定的length然后,我们返回结果的第一个元素。

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.