Given a character c and a number n, how can I create a String that consists of n repetitions of c? Doing it manually is too cumbersome:
StringBuilder sb = new StringBuilder(n); for (int i = 0; i < n; ++i) { sb.append(c); } String result = sb.toString(); Surely there is some static library function that already does this for me?
int n = 10; char[] chars = new char[n]; Arrays.fill(chars, 'c'); String result = new String(chars); EDIT:
It's been 9 years since this answer was submitted but it still attracts some attention now and then. In the meantime Java 8 has been introduced with functional programming features. Given a char c and the desired number of repetitions count the following one-liner can do the same as above.
String result = IntStream.range(1, count).mapToObj(index -> "" + c).collect(Collectors.joining()); Do note however that it is slower than the array approach. It should hardly matter in any but the most demanding circumstances. Unless it's in some piece of code that will be executed thousands of times per second it won't make much difference. This can also be used with a String instead of a char to repeat it a number of times so it's a bit more flexible. No third-party libraries needed.
Character object thanks to auto-unboxing. I'm assuming it's a char or Character.
(""+c).repeat(n)If you can, use StringUtils from Apache Commons Lang:
StringUtils.repeat("ab", 3); //"ababab" 
char instead of a String. The implementation in recent versions effectively does the same as my answer (using Arrays.fill). The version taking a String has a bunch of branching code paths for optimizations. If the input String is of length 1 it ends up calling the method taking a char. The versions before commons-lang3 seem to perform well too. If you happen to have commons-lang on your classpath you may as well use it.Google Guava Time!
Strings.repeat("a", 3) http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/base/Strings.html
To have an idea of the speed penalty, I have tested two versions, one with Array.fill and one with StringBuilder.
public static String repeat(char what, int howmany) { char[] chars = new char[howmany]; Arrays.fill(chars, what); return new String(chars); } and
public static String repeatSB(char what, int howmany) { StringBuilder out = new StringBuilder(howmany); for (int i = 0; i < howmany; i++) out.append(what); return out.toString(); } using
public static void main(String... args) { String res; long time; for (int j = 0; j < 1000; j++) { res = repeat(' ', 100000); res = repeatSB(' ', 100000); } time = System.nanoTime(); res = repeat(' ', 100000); time = System.nanoTime() - time; System.out.println("elapsed repeat: " + time); time = System.nanoTime(); res = repeatSB(' ', 100000); time = System.nanoTime() - time; System.out.println("elapsed repeatSB: " + time); } (note the loop in main function is to kick in JIT)
The results are as follows:
elapsed repeat : 65899 elapsed repeatSB: 305171 It is a huge difference
String#repeat(int count), introduced as part of Java SE 11, makes it quite easy to do.
Demo:
public class Main { public static void main(String[] args) { char ch = 'c'; int n = 20; String result = String.valueOf(ch).repeat(n); System.out.println(result); } } Output:
cccccccccccccccccccc 
take look at this sample
Integer n=10; String s="a"; String repeated = new String(new char[n]).replace("\0", s); answer taken form Simple way to repeat a String in java so vote up there
Here is an O(logN) method, based on the standard binary powering algorithm:
public static String repChar(char c, int reps) { String adder = Character.toString(c); String result = ""; while (reps > 0) { if (reps % 2 == 1) { result += adder; } adder += adder; reps /= 2; } return result; } Negative values for reps return the empty string.
+= for String takes O(1) time. I do not think that your assumption is reasonable.
+= is the unit operation so O(log N) is valid. But you're right pointing that, internally, += will be using a StringBuilder which can have an overhead.
n repeating characters, it means that n memory locations will have to be filled in with a value. This is O(N) at best. Your algorithm is string concatenation in a loop in disguise. Using a StringBuilder will eventually still come down to linear time at best.Just add it to your own...
public static String generateRepeatingString(char c, Integer n) { StringBuilder b = new StringBuilder(); for (Integer x = 0; x < n; x++) b.append(c); return b.toString(); } Or Apache commons has a utility class you can add.
Integer instead of int?
intValue (3 times) and valueOf (once/interaction) eventually creating a new Integer (x > 127)!I am adding another way to solve it:
public String buildString(Character character, int nTimes) { return String.format("%" + nTimes + "s", " ").replace(' ', character); } If you are not on Java 11+ (otherwise I would go with Arvind Kumar Avinash's answer), you can also combine String#join(CharSequence, Iterable<? extends CharSequence> and Collections#nCopies(int, T):
String result = String.join("", Collections.nCopies(c, n)); A simple and clean solution would be to use String.format and then replace characters with desired character.
String.format("%5s", "").replace(' ', '#') // Output : ##### you can just use String.repeat()
"#".repeat(5) 