Simple way to repeat a string

Prior Java 11: Strategies by version

Before Java 11, we had an array of tactics for repeating strings, each with its own charm. But they all had one aim – to keep the code as clean and loop-free as possible.

Modern Java (Java 8+):

In a Java 8 world, String.join was the hero we needed (but not the one we deserved):

String result = String.join("", Collections.nCopies(5, "hi")); // Like creating a Marvel team, but with strings!


Legacy Java (Java 7 and before):

In the ancient days of Java 7 and earlier, we would pull off some cool tricks with String.format:

String result = String.format("%0" + n + "d", 0).replace("0", s); // Just like magic!


Using libraries:

If you ever fancy a stroll outside Java’s ecosystem, you might enjoy StringUtils.repeat() from Apache Commons Lang:

String repeated = StringUtils.repeat("hi", 5);  // Repetition level: John Wick movies!


These methods are like the Avengers of string repetition - they make your code readable and maintainable while fighting off complex loops.

Catering to Java versions

Just as Alfred always had the right gadget for Batman, different Java versions provide the right tools for string repetition.

Error handling:

For those unexpected twists, String.repeat() in Java 11 handles zero or negative repeats like a champ:

"hi".repeat(0); // Returns "", because apparently nothing is something
"hi".repeat(-1); // Throws IllegalArgumentException, because "-1 repetitions" is as absurd as pineapple on pizza!


Libraries to the rescue:

Libraries save the day again! To work with reliable string repetition utilities, consider Apache Commons Lang or Guava:

String repeated = Strings.repeat("hi", 5); // There's more than one way to skin a string repetition!


Embracing these standard libraries creates maintainable and error-free code, just as Batman embraces the Batmobile for a smooth ride.

Traps and treasures

Handle string repetition wisely to avoid surprise party crashers:

• Negative indices should be handled to avoid runtime exceptions that feel like unexpected jumpscares.

• Be wary of memory overflow situations when the repetition counts soar higher than your office building.

• Null check your input strings so that pesky NullPointerException finds another place to haunt.

Creating maintainable code

Sensible string repetition is a key that unlocks a clean, maintainable codebase. Remember these guiding principles:

Choose simplicity:

Ensure your code is intuitive. Wouldn't you prefer road signs over riddles on a journey?

Embrace change:

Your code should roll with changing requirements. String.repeat() and Collections.nCopies() are like Transformers, ready to adapt!

Performance is key:

Striking a balance between readability and performance is essential. As Spock would say, "the needs of the many outweigh the needs of the CPU cycles".

Read the manual:

Spend quality time with Javadoc or other documentation. They secretly love visitors!