Generating a Java String of N Repeated Characters – 生成N个重复字符的Java字符串

最后修改: 2022年 1月 13日

1. Overview


In this tutorial, we’ll get familiar with different options for generating a String of N repeated characters. This comes in handy when we need to add padding whitespace, produce ASCII art, etc.


This problem is easily solved in JDK11, but if we’re using an earlier version, then there are many other solutions available. We’ll start with the most common ones and add other approaches from some libraries.


2. Example


Let’s define the constants we’ll use in all solutions to validate a generated string:


private static final String EXPECTED_STRING = "aaaaaaa";
private static final int N = 7;

So, the EXPECTED_STRING constant represents the string we need to generate in solutions. The N constant is used to define the number of character repetitions.

所以,EXPECTED_STRING常数代表我们需要在解决方案中生成的字符串。N 常数用于定义字符重复的数量。

Now, let’s inspect the options for generating a string of N repeated characters a.


3. The JDK11 String.repeat Function


Java has a repeat function to build copies of a source string:


String newString = "a".repeat(N);
assertEquals(EXPECTED_STRING, newString);

This allows us to repeat single characters, or multi-character strings:


String newString = "-->".repeat(5);
assertEquals("-->-->-->-->-->", newString);

The algorithm behind this uses loops to fill arrays of characters quite efficiently.


If we don’t have JDK11, then we will have to create an algorithm ourselves, or use one from a third party library. The best of these IS unlikely to be much faster or easier to use than the JDK11 native solution.


4. Common Ways to Build a String


4.1. StringBuilder With a for Loop


Let’s start with the StringBuilder class. We’ll iterate through a for loop N times appending the repeated character:


StringBuilder builder = new StringBuilder(N);
for (int i = 0; i < N; i++) {
String newString = builder.toString();
assertEquals(EXPECTED_STRING, newString);

With this approach, we get the desired string. This is probably the easiest method to understand, but it’s not necessarily the fastest at runtime.


4.2. char Array With a for Loop


We can fill a fixed size char array with our desired character and convert that to a string:


char[] charArray = new char[N];
for (int i = 0; i < N; i++) {
    charArray[i] = 'a';
String newString = new String(charArray);
assertEquals(EXPECTED_STRING, newString);

This ought to be faster, as it does not require a dynamically sized structure to store our string as we build it, and Java can efficiently convert a char array to String.


4.3. Arrays fill Method

4.3.Arrays fill方法

Rather than use a loop, we can use a library function to fill our array:


char charToAppend = 'a';
char[] charArray = new char[N];
Arrays.fill(charArray, charToAppend);
String newString = new String(charArray);
assertEquals(EXPECTED_STRING, newString);

This is shorter and is as efficient at runtime as the previous solution.


5. Generating the String With the repeat Method


5.1. The Apache repeat Method


This solution requires adding a new dependency for the Apache Commons library:

这个解决方案需要为Apache Commons库添加一个新的依赖项。


After adding this dependency, we can use the repeat method from the StringUtils class. It takes as the parameters a character for repeating and a number of times the character should be repeated:


char charToAppend = 'a';
String newString = StringUtils.repeat(charToAppend, N);
assertEquals(EXPECTED_STRING, newString);

5.2. The Guava repeat Method


Like the previous approach, this one requires a new dependency for the Guava library:



Other than the fact that it comes from a different library, this solution is identical to the Apache Commons one:

除了来自一个不同的库之外,这个解决方案与Apache Commons的解决方案是相同的。

String charToAppend = "a";
String newString = Strings.repeat(charToAppend, N);
assertEquals(EXPECTED_STRING, newString);

6. Generating the String With the nCopies Method


If we think of our target string as a collection of repeated substrings, then we could use a List utility to construct the list and then convert the resulting list into our final String. For this, we can use the nCopies method from the Collections class in the java.util package:


public static <T> List<T> nCopies(int n, T o);

While constructing a list of substrings is less effective than our solutions that use a fixed array of characters, it can be helpful to repeat a pattern of characters rather than just a single character.


6.1. String join and the nCopies Methods

6.1.String joinnCopies方法

Let’s create a list of single-character strings with the nCopies method and use String.join to convert it to our result:


String charToAppend = "a";
String newString = String.join("", Collections.nCopies(N, charToAppend));
assertEquals(EXPECTED_STRING, newString);

The String.join method needs a delimiter, for which we’re using the empty string.


6.2. Guava Joiner and the nCopies Method

6.2.Guava JoinernCopies方法

Guava offers an alternative string joiner, which we can also use:


String charToAppend = "a";
String newString = Joiner.on("").join(Collections.nCopies(N, charToAppend));
assertEquals(EXPECTED_STRING, newString);

7. Generating the String With the Stream generate Method

7.用Stream generate方法生成字符串

The disadvantage of creating a list of substrings is that we’re creating a potentially large temporary list object before we construct our final string.


However, since Java 8, we can use the generate method from the Stream API. In combination with the limit method (for defining the length) and the collect method, we can generate a string of N repeated characters:

然而,从Java 8开始,我们可以使用Stream API中的generate方法。结合limit方法(用于定义长度)和collect方法,我们可以生成N个重复字符的字符串

String charToAppend = "a";
String newString = generate(() -> charToAppend)
assertEquals(exampleString, newString);

8. Generating the String With Apache’s RandomStringUtils


The RandomStringUtils class from the Apache Commons library enables generating a string of N repeated characters using the random method. We have to define a character and the number of repetitions:

来自Apache Commons库的RandomStringUtils类能够使用random方法生成N个重复字符的字符串。我们必须定义一个字符和重复的数量。

String charToAppend = "a";
String newString = RandomStringUtils.random(N, charToAppend);
assertEquals(EXPECTED_STRING, newString);

9. Conclusion


In this article, we saw various solutions for generating a string of N repeated characters. The easiest of these is String.repeat, available from JDK 11 onwards.

在这篇文章中,我们看到了生成N个重复字符的字符串的各种解决方案。其中最简单的是String.repeat,从JDK 11开始可用。

For earlier versions of Java there are many other possible available options. The best choice will depend on our requirements in terms of runtime efficiency, ease of coding, and availability of libraries.


As always, the code for these examples is available over on GitHub.