java中有没有一种方法可以创建具有指定字符数的字符串？就我而言，我需要创建一个包含 10 个空格的字符串。我目前的代码是：
StringBuffer outputBuffer = new StringBuffer(length);
for (int i = 0; i < length; i++){
outputBuffer.append(" ");
}
return outputBuffer.toString();
有没有更好的方法来完成同样的事情。特别是我想要一些快速的东西（在执行方面）。
可能是使用 API 的最短代码String，专门：
String space10 = new String(new char[10]).replace('\0', ' ');
System.out.println("[" + space10 + "]");
// prints "[ ]"
作为一种方法，无需直接实例化char：
import java.nio.CharBuffer;
/**
* Creates a string of spaces that is 'spaces' spaces long.
*
* @param spaces The number of spaces to add to the string.
*/
public String spaces( int spaces ) {
return CharBuffer.allocate( spaces ).toString().replace( '\0', ' ' );
}
调用使用：
System.out.printf( "[%s]%n", spaces( 10 ) );
我强烈建议不要手动编写循环。在您的编程生涯中，您将一遍又一遍地这样做。阅读你的代码的人——包括你——总是需要花费时间来消化循环的含义，即使只有几秒钟。
而是重用StringUtils.repeat提供代码的可用库之一，就像Apache Commons Lang一样：
StringUtils.repeat(' ', length);
这样你也不必担心性能，因此所有的血腥细节StringBuilder，编译器优化等都被隐藏了。如果该函数结果很慢，那将是库的错误。
使用Java 11，它变得更加容易：
" ".repeat(length);
嗯，现在我想起来了，也许Arrays.fill：
char[] charArray = new char[length];
Arrays.fill(charArray, ' ');
String str = new String(charArray);
当然，我假设该fill方法与您的代码执行相同的操作，因此它的执行可能大致相同，但至少行数更少。
for 循环将由编译器进行优化。在像您这样的情况下，您不需要自己关心优化。相信编译器。
顺便说一句，如果有一种方法可以创建一个包含 n 个空格字符的字符串，那么它的编码方式与您刚才所做的相同。
" ".repeat(10);
generate(() -> " ").limit(10).collect(joining());
在哪里：
import static java.util.stream.Collectors.joining;
import static java.util.stream.Stream.generate;
在 Java 8 中，您可以使用String.join：
String.join("", Collections.nCopies(n, s));
如果您只想要空格，那么如何：
String spaces = (n==0)?"":String.format("%"+n+"s", "");
这将导致 abs(n) 空格；
从 Java 11 开始，您可以简单地使用它String.repeat(count)来解决您的问题。
返回一个字符串，其值为该字符串重复
count次数的串联。如果此字符串为空或
count为零，则返回空字符串。
因此，您的代码将如下所示，而不是循环：
" ".repeat(length);
我认为这是可能的代码更少，它使用 Guava Joiner 类：
Joiner .on("").join( Collections.nCopies (10, " "));
您可以使用标准String.format函数生成 N 个空格。例如：
String.format("%5c", ' ');
创建一个有 5 个空格的字符串。
或者
int count = 15;
String fifteenSpacebars = String.format("%" + count + "c", ' ');
制作一串 15 个空格键。
如果要重复另一个符号，则必须用所需符号替换空格：
int count = 7;
char mySymbol = '#';
System.out.println(String.format("%" + count + "c", ' ').replaceAll("\\ ", "\\" + mySymbol));
输出：
#######
我的贡献基于快速求幂算法。
/**
* Repeats the given {@link String} n times.
*
* @param str
* the {@link String} to repeat.
* @param n
* the repetition count.
* @throws IllegalArgumentException
* when the given repetition count is smaller than zero.
* @return the given {@link String} repeated n times.
*/
public static String repeat(String str, int n) {
if (n < 0)
throw new IllegalArgumentException(
"the given repetition count is smaller than zero!");
else if (n == 0)
return "";
else if (n == 1)
return str;
else if (n % 2 == 0) {
String s = repeat(str, n / 2);
return s.concat(s);
} else
return str.concat(repeat(str, n - 1));
}
我针对其他两种方法测试了该算法：
String.concat()用于连接字符串的常规 for 循环StringBuilder测试代码（使用 for 循环连接并且String.concat()对于 large 变得很慢n，所以我在第 5 次迭代后将其省略了）。
/**
* Test the string concatenation operation.
*
* @param args
*/
public static void main(String[] args) {
long startTime;
String str = " ";
int n = 1;
for (int j = 0; j < 9; ++j) {
n *= 10;
System.out.format("Performing test with n=%d\n", n);
startTime = System.currentTimeMillis();
StringUtil.repeat(str, n);
System.out
.format("\tStringUtil.repeat() concatenation performed in %d milliseconds\n",
System.currentTimeMillis() - startTime);
if (j <5) {
startTime = System.currentTimeMillis();
String string = "";
for (int i = 0; i < n; ++i)
string = string.concat(str);
System.out
.format("\tString.concat() concatenation performed in %d milliseconds\n",
System.currentTimeMillis() - startTime);
} else
System.out
.format("\tString.concat() concatenation performed in x milliseconds\n");
startTime = System.currentTimeMillis();
StringBuilder b = new StringBuilder();
for (int i = 0; i < n; ++i)
b.append(str);
b.toString();
System.out
.format("\tStringBuilder.append() concatenation performed in %d milliseconds\n",
System.currentTimeMillis() - startTime);
}
}
结果：
Performing test with n=10
StringUtil.repeat() concatenation performed in 0 milliseconds
String.concat() concatenation performed in 0 milliseconds
StringBuilder.append() concatenation performed in 0 milliseconds
Performing test with n=100
StringUtil.repeat() concatenation performed in 0 milliseconds
String.concat() concatenation performed in 1 milliseconds
StringBuilder.append() concatenation performed in 0 milliseconds
Performing test with n=1000
StringUtil.repeat() concatenation performed in 0 milliseconds
String.concat() concatenation performed in 1 milliseconds
StringBuilder.append() concatenation performed in 1 milliseconds
Performing test with n=10000
StringUtil.repeat() concatenation performed in 0 milliseconds
String.concat() concatenation performed in 43 milliseconds
StringBuilder.append() concatenation performed in 5 milliseconds
Performing test with n=100000
StringUtil.repeat() concatenation performed in 0 milliseconds
String.concat() concatenation performed in 1579 milliseconds
StringBuilder.append() concatenation performed in 1 milliseconds
Performing test with n=1000000
StringUtil.repeat() concatenation performed in 0 milliseconds
String.concat() concatenation performed in x milliseconds
StringBuilder.append() concatenation performed in 10 milliseconds
Performing test with n=10000000
StringUtil.repeat() concatenation performed in 7 milliseconds
String.concat() concatenation performed in x milliseconds
StringBuilder.append() concatenation performed in 112 milliseconds
Performing test with n=100000000
StringUtil.repeat() concatenation performed in 80 milliseconds
String.concat() concatenation performed in x milliseconds
StringBuilder.append() concatenation performed in 1107 milliseconds
Performing test with n=1000000000
StringUtil.repeat() concatenation performed in 1372 milliseconds
String.concat() concatenation performed in x milliseconds
StringBuilder.append() concatenation performed in 12125 milliseconds
结论：
n- 使用递归方法n- for 循环有足够的速度这个怎么样？
char[] bytes = new char[length];
Arrays.fill(bytes, ' ');
String str = new String(bytes);
考虑到我们有：
String c = "c"; // character to repeat, for empty it would be " ";
int n = 4; // number of times to repeat
String EMPTY_STRING = ""; // empty string (can be put in utility class)
String resultOne = IntStream.range(0,n)
.mapToObj(i->c).collect(Collectors.joining(EMPTY_STRING)); // cccc
String resultTwo = String.join(EMPTY_STRING, Collections.nCopies(n, c)); //cccc
RandomStringUtils可以根据给定的输入大小创建字符串。不能评论速度，但它是一个班轮。
RandomStringUtils.random(5,"\t");
创建一个输出
\t\t\t\t\t
如果您不想在代码中看到\0 ，则更可取。
使用 StringUtils： StringUtils.repeat(' ', 10)
这对我来说没有在 Java 8 中使用任何外部库
String sampleText = "test"
int n = 3;
String output = String.join("", Collections.nCopies(n, sampleText));
System.out.println(output);
输出是
testtesttest
诠释 c = 10; 字符串空格 = String.format("%" +c+ "c", ' '); 这将解决您的问题。
在大多数情况下，您只需要达到一定长度的字符串，比如 100 个空格。您可以准备一个字符串数组，其中索引号等于空格填充字符串的大小并查找字符串，如果所需的长度在限制范围内，或者如果它在边界之外，则按需创建它。
为了获得良好的性能，结合来自aznilamir和FrustratedWithFormsDesigner的答案
private static final String BLANKS = " ";
private static String getBlankLine( int length )
{
if( length <= BLANKS.length() )
{
return BLANKS.substring( 0, length );
}
else
{
char[] array = new char[ length ];
Arrays.fill( array, ' ' );
return new String( array );
}
}
BLANKS根据您的要求调整大小。我的特定BLANKS字符串长度约为 200 个字符。
只需用 StringBuilder 替换您的StringBuffer。很难打败它。
如果您的长度很大，您可能会实现一些更有效（但更笨拙）的自附加，在每次迭代中复制长度：
public static String dummyString(char c, int len) {
if( len < 1 ) return "";
StringBuilder sb = new StringBuilder(len).append(c);
int remnant = len - sb.length();
while(remnant > 0) {
if( remnant >= sb.length() ) sb.append(sb);
else sb.append(sb.subSequence(0, remnant));
remnant = len - sb.length();
}
return sb.toString();
}
另外，您可以尝试这种Arrays.fill()方法（FrustratedWithFormsDesigner的答案）。
您可以替换StringBuffer为StringBuilder（后者不同步，在单线程应用程序中可能更快）
您可以创建StringBuilder一次实例，而不是每次需要时都创建它。
像这样的东西：
class BuildString {
private final StringBuilder builder = new StringBuilder();
public String stringOf( char c , int times ) {
for( int i = 0 ; i < times ; i++ ) {
builder.append( c );
}
String result = builder.toString();
builder.delete( 0 , builder.length() -1 );
return result;
}
}
并像这样使用它：
BuildString createA = new BuildString();
String empty = createA.stringOf( ' ', 10 );
如果您将您的createA作为实例变量，您可以节省创建实例的时间。
这不是线程安全的，如果你有多个线程，每个线程都应该有自己的副本。
有这样的方法。这会在给定的末尾附加所需的空格，String以使给定String的长度为特定长度。
public static String fillSpaces (String str) {
// the spaces string should contain spaces exceeding the max needed
String spaces = " ";
return str + spaces.substring(str.length());
}
希望字符串具有固定大小，因此您可以填充或截断，以制表数据...
class Playground {
private static String fixStrSize(String s, int n) {
return String.format("%-" + n + "s", String.format("%." + n +"s", s));
}
public static void main(String[ ] args) {
System.out.println("|"+fixStrSize("Hell",8)+"|");
System.out.println("|"+fixStrSize("Hells Bells Java Smells",8)+"|");
}
}
|Hell |
|Hells Be|
这里有很好的参考。
也可以使用如下简单的方法
public static String padString(String str, int leng,char chr) {
for (int i = str.length(); i <= leng; i++)
str += chr;
return str;
}
这个怎么样？
public String fillSpaces(int len) {
/* the spaces string should contain spaces exceeding the max needed */
String spaces = " ";
return spaces.substring(0,len);
}
编辑：我编写了一个简单的代码来测试这个概念以及我发现的内容。
方法1：在循环中添加单个空格：
public String execLoopSingleSpace(int len){
StringBuilder sb = new StringBuilder();
for(int i=0; i < len; i++) {
sb.append(' ');
}
return sb.toString();
}
方法2：追加100个空格并循环，然后是子串：
public String execLoopHundredSpaces(int len){
StringBuilder sb = new StringBuilder(" ")
.append(" ").append(" ").append(" ")
.append(" ").append(" ").append(" ")
.append(" ").append(" ").append(" ");
for (int i=0; i < len/100 ; i++) {
sb.append(" ")
.append(" ").append(" ").append(" ")
.append(" ").append(" ").append(" ")
.append(" ").append(" ").append(" ");
}
return sb.toString().substring(0,len);
}
结果我创建了 12,345,678 个空格：
C:\docs\Projects> java FillSpace 12345678
method 1: append single spaces for 12345678 times. Time taken is **234ms**. Length of String is 12345678
method 2: append 100 spaces for 123456 times. Time taken is **141ms**. Length of String is 12345678
Process java exited with code 0
对于 10,000,000 个空格：
C:\docs\Projects> java FillSpace 10000000
method 1: append single spaces for 10000000 times. Time taken is **157ms**. Length of String is 10000000
method 2: append 100 spaces for 100000 times. Time taken is **109ms**. Length of String is 10000000
Process java exited with code 0
结合直接分配和迭代总是花费更少的时间，在创建巨大空间时平均减少 60 毫秒。对于较小的尺寸，这两个结果都可以忽略不计。
但请继续评论:-)
我知道您所询问的内容没有内置方法。但是，对于像 10 这样的小固定长度，您的方法应该足够快。