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.
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++) {
builder.append("a");
}
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
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:
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.13.0</version>
</dependency>
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:
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<version>32.1.3-jre</version>
</dependency>
Other than the fact that it comes from a different library, this solution is identical to the Apache Commons one:
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
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
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
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:
String charToAppend = "a";
String newString = generate(() -> charToAppend)
.limit(length)
.collect(Collectors.joining());
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:
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.
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.
