给定一个字符 c 和一个数字 n，我如何创建一个包含 n 个 c 重复的字符串？手动操作太麻烦了：
StringBuilder sb = new StringBuilder(n);
for (int i = 0; i < n; ++i)
{
sb.append(c);
}
String result = sb.toString();
肯定有一些静态库函数已经为我做了这个？
【问题讨论】：
只需将其添加到您自己的...
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 有一个可以添加的实用程序类。
【讨论】：
Integer而不是int？
intValue（3 次）和valueOf（一次/交互）最终创建一个新的整数（x > 127）！
int n = 10;
char[] chars = new char[n];
Arrays.fill(chars, 'c');
String result = new String(chars);
编辑：
自提交此答案已有 9 年了，但它仍然不时引起一些关注。与此同时，Java 8 引入了函数式编程特性。给定一个字符c 和所需的重复次数count，下面的单行代码可以和上面一样。
String result = IntStream.range(1, count).mapToObj(index -> "" + c).collect(Collectors.joining());
但请注意，它比数组方法慢。除了最苛刻的情况外，它几乎不重要。除非它是在每秒执行数千次的代码中，否则不会有太大的不同。这也可以与 String 而不是 char 一起使用以重复多次，因此更加灵活。无需第三方库。
【讨论】：
Character 对象。我假设它是char 或Character。
(""+c).repeat(n)
如果可以，请使用来自 Apache Commons 的 StringUtils Lang：
StringUtils.repeat("ab", 3); //"ababab"
【讨论】：
char 而不是String 的方法。最近版本中的实现实际上与我的答案相同（使用Arrays.fill）。采用 String 的版本有一堆用于优化的分支代码路径。如果输入字符串的长度为 1，它最终会调用采用 char 的方法。 commons-lang3 之前的版本似乎也表现良好。如果你的类路径中碰巧有 commons-lang，你也可以使用它。
谷歌番石榴时间！
Strings.repeat("a", 3)
http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/base/Strings.html
【讨论】：
这是一个 O(logN) 方法，基于标准的二进制幂算法：
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;
}
reps 的负值返回空字符串。
【讨论】：
+= for String 需要 O(1) 时间，这需要 O(log N) 时间。我不认为你的假设是合理的。
+= 是单位运算，因此 O(log N) 是有效的。但是您说得对，在内部，+= 将使用 StringBuilder，这可能会产生开销。
n 重复字符，这意味着n 内存位置必须用一个值填充。这充其量是 O(N)。您的算法是变相的循环中的字符串连接。使用 StringBuilder 最终最多仍会归结为线性时间。
看看这个样本
Integer n=10;
String s="a";
String repeated = new String(new char[n]).replace("\0", s);
以Simple way to repeat a String in java 的形式回答，所以在那里投票
【讨论】：
为了了解速度损失，我测试了两个版本，一个使用 Array.fill，一个使用 StringBuilder。
public static String repeat(char what, int howmany) {
char[] chars = new char[howmany];
Arrays.fill(chars, what);
return new String(chars);
}
和
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();
}
使用
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);
}
（注意 main 函数中的循环是为了启动 JIT）
结果如下：
elapsed repeat : 65899
elapsed repeatSB: 305171
这是一个巨大的差异
【讨论】：
我正在添加另一种解决方法：
public String buildString(Character character, int nTimes) {
return String.format("%" + nTimes + "s", " ").replace(' ', character);
}
【讨论】：
String#repeat(int count)，作为 Java SE 11 的一部分引入，使其非常容易实现。
演示：
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);
}
}
输出：
cccccccccccccccccccc
【讨论】：
如果您不在 Java 11+ 上（否则我会选择 Arvind Kumar Avinash's answer），您还可以结合使用 String#join(CharSequence, Iterable<? extends CharSequence> 和 Collections#nCopies(int, T)：
String result = String.join("", Collections.nCopies(c, n));
【讨论】：