创建一个包含n个字符的字符串

Question

java中是否有一种方法可以创建具有指定数量的指定字符的字符串？在我的例子中,我需要创建一个包含10个空格的字符串.我目前的代码是:

StringBuffer outputBuffer = new StringBuffer(length);
for (int i = 0; i < length; i++){
   outputBuffer.append(" ");
}
return outputBuffer.toString();

有没有更好的方法来完成同样的事情.特别是我想要一些快速的(在执行方面).

Answer 1

可能是使用StringAPI 的最短代码,仅限:

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 ) );

Answer 2

嗯,现在我想起来,也许Arrays.fill:

char[] charArray = new char[length];
Arrays.fill(charArray, ' ');
String str = new String(charArray);

当然,我假设该fill方法与您的代码完全相同,因此它可能会执行相同的操作,但至少这是更少的行.

Answer 3

我强烈建议不要手工编写循环.你将在编程生涯中一遍又一遍地做这件事.阅读你的代码的人 - 包括你 - 总是需要花时间,即使只是几秒钟,消化循环的意义.

而是重用一个可用的库,提供StringUtils.repeat与Apache Commons Lang类似的代码:

StringUtils.repeat(' ', length);

这样你也不必担心性能问题,因此StringBuilder隐藏了编译器优化等所有血腥细节.如果函数变得很慢,那么这将是库的错误.

使用Java 11,它变得更加容易:

" ".repeat(length);

Answer 4

for循环将由编译器优化.在像你这样的情况下,你不需要自己关心优化.相信编译器.:)

编辑:顺便说一句,如果有一种方法可以创建一个包含n个空格字符的字符串,那么它的编码方式与您刚刚编写的方式相同.

Answer 5

从Java 11 开始：

" ".repeat(10);

从Java 8 开始：

generate(() -> " ").limit(10).collect(joining());

在哪里：

import static java.util.stream.Collectors.joining;
import static java.util.stream.Stream.generate;

Answer 6

在Java 8中,您可以使用String.join:

String.join("", Collections.nCopies(n, s));

Answer 7

如果你只想要空格,那么怎么样:

String spaces = (n==0)?"":String.format("%"+n+"s", "");

这会产生abs(n)空间;

Answer 8

我认为这是可能的代码越少,它使用的是Guava Joiner类:

Joiner .on("").join(Collections.nCopies(10,""));

Answer 9

我的贡献基于快速取幂算法.

/**
 * 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()用于连接字符串
• 定期循环使用a 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循环有足够的速度

Answer 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));

输出：

#######

Answer 11

从Java 11开始，您可以简单地使用它String.repeat(count)来解决您的问题。

返回一个字符串，其值是该字符串的重复count次数。

如果此字符串为空或count为零，则返回空字符串。

因此，除了循环，您的代码将如下所示：

" ".repeat(length);