创build一个n个字符的string
有没有办法在Java中创build一个指定字符的指定数字的string？ 在我的情况下，我需要创build一个10个string的string。 我目前的代码是：
StringBuffer outputBuffer = new StringBuffer(length); for (int i = 0; i < length; i++){ outputBuffer.append(" "); } return outputBuffer.toString(); 有没有更好的方法来完成同样的事情。 特别是我想要一些速度很快的东西（就执行而言）。
for循环将被编译器优化。 在像你这样的情况下，你不需要关心自己的优化。 相信编译器。 🙂
编辑：顺便说一句，如果有一种方法来创build一个具有n个空格字符的string，而不是像你刚才那样编码。
可能使用String API的最短代码是：
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 ) );
嗯，现在我想想，也许Arrays.fill ：
char[] charArray = new char[length]; Arrays.fill(charArray, ' '); String str = new String(charArray);
当然，我认为fill方法和你的代码是一样的，所以它可能会执行相同的操作，但是至less这是less了几行。
我强烈build议不要手动编写循环。 在你的编程生涯中，你会一遍又一遍地做到这一点。 阅读你的代码的人 – 包括你 – 总是需要花费时间来消化循环的意义，即使仅仅是几秒钟。
相反， 重用一个可用库来提供代码，就像Apache Commons Lang中的 StringUtils.repeat一样：
return StringUtils.repeat(' ', length);
这样你也不必担心性能，所以StringBuilder所有细节，编译器优化等都是隐藏的。 如果这个函数变慢，那么这个库就是一个bug。
如果你只想要空格，那么怎么样：
String spaces = (n==0)?"":String.format("%"+n+"s", "");
这将导致abs（n）空间;
我认为这是可能的更less的代码，它使用Guava Joiner类：
joiner.on（“”）。join（ Collections.nCopies （10，“”））;
在Java 8中，您可以使用String.join ：
String.join("", Collections.nCopies(n, s));
这个怎么样？
char[] bytes = new char[length]; Arrays.fill(bytes, ' '); String str = new String(bytes);
我的贡献基于快速求幂的algorithm。
/** * 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)); }
我用另外两种方法testing了algorithm：
- 定期用循环使用
String.concat()来连接string - 使用
StringBuilder定期循环
testing代码（使用for循环和String.concat()变得对于大的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使用recursion方法 - 对于小的
n– for循环有足够的速度
RandomStringUtils提供了从给定的input大小创build一个string。 不能评论速度，但它是一个class轮。
RandomStringUtils.random(5,"\t");
创build一个输出
\吨\吨\吨\吨\吨
最好如果你不想在你的代码中看到\ 0 。
在大多数情况下，你只需要弦长达一定的长度，比如说100个空格。 您可以准备一个string数组，其索引号等于空格填充string的大小，并查找string，如果所需长度在限制范围内，或者在边界之外按需创build。
用StringBuilderreplace你的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的答案）。
你可以用StringBufferreplaceStringBuffer （后者不是同步的，在单个线程应用中可能会更快）
而且您可以创build一次StringBuilder实例，而不是在每次需要时创build它。
像这样的东西：
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作为实例variables保存，则可以节省创build实例的时间。
这不是线程安全的，如果你有multithreading，每个线程应该有自己的副本。
为了获得良好的性能，结合来自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大小。 我的具体BLANKSstring长度大约为200个字符。
有一个这样的方法。 这会在给定的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()); }
像下面这样简单的方法也可以使用
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); }
编辑：我写了一个简单的代码来testing这个概念，在这里我发现了什么。
方法1：在循环中添加单个空间：
public String execLoopSingleSpace(int len){ StringBuilder sb = new StringBuilder(); for(int i=0; i < len; i++) { sb.append(' '); } return sb.toString(); }
方法2：追加100个空格和循环，然后子string：
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); }
结果我创build了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
结合直接分配和迭代总是需要更less的时间，创build巨大的空间时平均减less60ms。 对于较小的尺寸，两个结果都可以忽略不计。
但请继续评论:-)
我不知道你在问什么内置的方法。 但是，对于像10这样的小固定长度，您的方法应该足够快。
