在java中是否有办法创建具有指定数量的指定字符的字符串？在我的例子中，我需要创建一个包含10个空格的字符串。我目前的代码是：
StringBuffer outputBuffer = new StringBuffer(length);
for (int i = 0; i < length; i++){
outputBuffer.append(" ");
}
return outputBuffer.toString();
有没有更好的方法来完成同样的事情。特别是我想要一些快速的（在执行方面）。
答案 0 :(得分：149)
可能是使用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 ) );
答案 1 :(得分：56)
嗯，现在我想起来了，也许是Arrays.fill：
char[] charArray = new char[length];
Arrays.fill(charArray, ' ');
String str = new String(charArray);
当然，我假设fill方法与你的代码做同样的事情，所以它可能会执行相同的操作，但至少这是更少的行。
答案 2 :(得分：55)
我强烈建议不要手工编写循环。 你将在编程生涯中一遍又一遍地做这件事。 阅读你的代码的人 - 包括你 - 总是需要花时间，即使只是几秒钟，也要消化循环的意义。
而是重复使用其中一个可用库，提供的代码与Apache Commons Lang中的StringUtils.repeat类似：
StringUtils.repeat(' ', length);
这样你也不必担心性能问题，因此隐藏了StringBuilder，编译器优化等所有血腥细节。
如果函数结果很慢，则会成为库的错误。
使用Java 11变得更加容易：
" ".repeat(length);
答案 3 :(得分：34)
for循环将由编译器优化。在像你这样的情况下，你不需要自己关心优化。相信编译器。 ：）
编辑：顺便说一句，如果有一种方法可以创建一个包含n个空格字符的字符串，那么它的编码方式与您刚刚编写的相同。
答案 4 :(得分：21)
在Java 8中，您可以使用String.join("", Collections.nCopies(n, s));
：
def parse(filename):
tweets=[]
with open(filename,'r') as filename:
tree = ET.parse(filename)
root = tree.getroot()
for document in root.iter('document'):
txt=document.text
txt=txt.replace("![CDATA[",'')
txt=txt.replace("]]",'')
txt=txt.strip()
tweets.append(document.text)
return ' '.join(tweets)
答案 5 :(得分：12)
如果你只想要空格，那么如何：
String spaces = (n==0)?"":String.format("%"+n+"s", "");
将导致abs（n）空格;
答案 6 :(得分：8)
我认为这是可能的代码较少，它使用的是Guava Joiner类：
Joiner。on（“”）。join（Collections.nCopies（10，“”））;
答案 7 :(得分：5)
我的贡献基于快速求幂算法。
/**
* 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()循环使用来循环StringBuilder 测试代码（使用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 - 使用递归方法n - for循环有足够的速度答案 8 :(得分：3)
这个怎么样？
char[] bytes = new char[length];
Arrays.fill(bytes, ' ');
String str = new String(bytes);
答案 9 :(得分：2)
自 Java 11 起：
" ".repeat(n);
由于 Java 8 ：
Stream.generate(() -> ch).limit(n).collect(joining());
其中：
import static java.util.stream.Collectors.joining;
import java.util.stream.Stream;
...
String ch = " ";
int n = 10;
Stream
.generate(() -> ch)
.limit(n)
.collect(joining());
答案 10 :(得分：2)
您可以使用标准的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));
输出：
#######
答案 11 :(得分：2)
RandomStringUtils有一个从给定输入大小创建字符串的规定。 不能评论速度，但它是一个单线。
RandomStringUtils.random(5,"\t");
创建输出
\吨\吨\吨\吨\吨
如果你不想在你的代码中看到 \ 0 ，那就更好了。
答案 12 :(得分：1)
使用StringUtils： StringUtils.repeat（''，10）
答案 13 :(得分：1)
在大多数情况下，你只需要一定长度的字符串，比如100个空格。您可以准备一个字符串数组，其索引号等于空格填充字符串的大小，并查找字符串，如果所需长度在限制范围内，或者如果它在边界之外，则按需创建。
答案 14 :(得分：1)
考虑到我们有：
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
答案 15 :(得分：0)
从Java 11开始，您只需使用String.repeat(count)即可解决问题。
返回一个字符串，该字符串的值是此字符串的串联重复
count次。如果此字符串为空或
count为零，则返回空字符串。
因此，不是循环，您的代码将如下所示：
" ".repeat(length);
答案 16 :(得分：0)
int c = 10; 字符串空间= String.format（“％” + c +“ c”，''）; 这将解决您的问题。
答案 17 :(得分：0)
答案 18 :(得分：0)
想要的字符串具有固定大小，因此您可以填充或截断以制表数据...
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|
优秀参考文献here。
答案 19 :(得分：0)
这对我来说无需使用Java 8中的任何外部库即可解决
String sampleText = "test"
int n = 3;
String output = String.join("", Collections.nCopies(n, sampleText));
System.out.println(output);
输出为
testtesttest
答案 20 :(得分：0)
有这样的方法。这会在给定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());
}
答案 21 :(得分：0)
为了获得良好的效果，请合并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个字符。
答案 22 :(得分：0)
您可以将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作为实例变量，则可以节省创建实例的时间。
这不是线程安全的，如果你有多个线程，每个线程都应该有自己的副本。
答案 23 :(得分：0)
只需用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() aproach（ FrustratedWithFormsDesigner 的答案）。
答案 24 :(得分：-1)
也可以使用如下的简单方法
public static String padString(String str, int leng,char chr) {
for (int i = str.length(); i <= leng; i++)
str += chr;
return str;
}
答案 25 :(得分：-2)
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
组合直接分配和迭代总是花费更少的时间，在创建大空间时平均减少60ms。对于较小的尺寸，两种结果都可以忽略不计。
但请继续评论： - ）
答案 26 :(得分：-3)
我知道你所询问的内容没有内置方法。但是，对于像10这样的小固定长度，你的方法应该足够快。