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

最后修改: 2022年 7月 13日

中文/混合/英文(键盘快捷键：t)

1. Overview

1.概述

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

在本教程中，我们将学习在Java中截断一个String到所需字符数的多种方法。

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.

我们将首先探索使用JDK本身来实现这一目标的方法。然后，我们将看看如何使用一些流行的第三方库来实现这一目标。

2. Truncating a String Using the JDK

2.使用JDK截断一个字符串

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

Java提供了许多方便的方法来截断String。让我们来看看。

2.1. Using String’s substring() Method

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

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.

String类附带了一个方便的方法，叫做substring。如其名所示，substring()返回给定String在指定索引之间的部分。

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.

在上面的例子中，如果指定的length大于text的长度，我们返回text本身。这是因为传递给substring()的length大于String的字符数会导致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.

否则，我们将返回从索引0开始并延伸到–但不包括–索引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.

正如我们所看到的，起始索引是包容的，结束索引是排他的。因此，索引length处的字符将不会被包含在返回的子串中。

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.

截断字符串的另一种方法是使用split()方法，该方法使用正则表达式将字符串分成若干部分。

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.

results的第一个元素将是我们截断的String，如果length长于text，则是原始String。

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

2.3.使用Pattern 类

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 + "}")
      .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.

正如我们在上面看到的，在将我们的正则表达式编译成Pattern之后，我们可以使用Pattern的matcher()方法来根据该正则解释我们的String。然后我们就可以对结果进行分组，并返回第一个结果，也就是我们截断的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

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()
      .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.

在这里，我们使用limit()方法来限制Stream到给定的长度。然后我们使用StringBuilder来构建我们的截断字符串。

Next, let’s verify that our method works:

接下来，让我们验证一下我们的方法是否有效。

@Test
public void givenStringAndLength_whenUsingCodePointsMethod_thenTrim() {

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

3. Apache Commons Library

3.阿帕奇共享图书馆

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。

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

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:

StringUtils有一个有用的static方法，叫做left()。StringUtils.left()以无效安全的方式返回String最左边的指定字符数：。

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:

另外，我们可以使用StringUtils.truncate()来达到同样的目的。

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

    return StringUtils.truncate(text, length);
}

4. Guava Library

4.番石榴图书馆

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文件中。

<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:

现在我们可以使用Guava的Splitter类来截断我们的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.

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

5. Conclusion

5.总结

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

在这篇文章中，我们学习了在Java中把一个String截断到特定数量的字符的各种方法。

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

我们看了一些使用JDK来做这件事的方法。然后我们使用几个第三方库来截断Strings。

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

一如既往，本文中所使用的代码可以在GitHub上找到over。