Question

是否有一种简单的方法可以将字符或其他字符串n次添加到现有字符串中？我在String，Stringbuilder等

中找不到任何内容

Answer 1

Apache commons-lang3有StringUtils.repeat(String, int)，您可以这样做（为简单起见，而不是StringBuilder）：

String original;
original = original + StringUtils.repeat("x", n);

由于它是开源的，您可以阅读它的编写方式。如果我没记错的话，小n-s有一个小的优化，但大部分时间它使用StringBuilder。

Answer 2

对于重复单个字符（不是字符串）的情况，您可以使用Arrays.fill：

  String original = "original ";
  char c = 'c';
  int number = 9;

  char[] repeat = new char[number];
  Arrays.fill(repeat, c);
  original += new String(repeat);

Answer 3

您可以使用Java 8流API执行此操作。以下代码从"cccc"创建字符串"c"：

String s = "c";
int n = 4;
String sRepeated = IntStream.range(0, n).mapToObj(i -> s).collect(Collectors.joining(""));

Answer 4

对于Java 8，您可以这样做：

int n = 4;
String existing = "...";
String result = existing + String.join("", Collections.nCopies(n, "*"));

输出：

...****

在Java 8中添加了String.join方法。但Collections.nCopies甚至在Java 5中也是如此。

Answer 5

使用此：

String input = "original";
String newStr = "new"; //new string to be added
int n = 10 // no of times we want to add
input = input + new String(new char[n]).replace("\0", newStr);

Answer 6

您可以使用Guava的Strings.repeat方法：

String existingString = ...
existingString += Strings.repeat("foo", n);

Answer 7

最好使用StringBuilder而不是String，因为String是一个不可变类，一旦创建就无法修改：在String中，每个连接都会导致创建一个String类的新实例并修改字符串。

Answer 8

for(int i = 0; i < n; i++) {
    existing_string += 'c';
}

但你应该使用StringBuilder，并节省内存

int n = 3;
String existing_string = "string";
StringBuilder builder = new StringBuilder(existing_string);
for (int i = 0; i < n; i++) {
    builder.append(" append ");
}

System.out.println(builder.toString());

Answer 9

除了上述答案之外，您还应该使用适当的容量初始化StringBuilder，尤其是您已经知道的容量。例如：

int capacity = existingString.length() + n * appendableString.length();
StringBuilder builder = new StringBuilder(capacity);

Answer 10

public String appendNewStringToExisting(String exisitingString, String newString, int number) {
    StringBuilder builder = new StringBuilder(exisitingString);
    for(int iDx = 0; iDx < number; iDx++){
        builder.append(newString);
    }
    return builder.toString();
}

Answer 11

 String toAdd = "toAdd";
 StringBuilder s = new StringBuilder();
 for(int count = 0; count < MAX; count++) {
     s.append(toAdd);
  }
  String output = s.toString();

Answer 12

请记住，如果＆＃34; n＆＃34;很大，使用+ =可能不是一个好主意，因为每次通过+ =添加另一个String时，JVM都会创建一个全新的对象（关于此的大量信息）。

类似的东西：

StringBuilder b = new StringBuilder(existing_string);
for(int i = 0; i<n; i++){
    b.append("other_string");
}
return b.toString();

实际上并没有在IDE中对此进行编码，因此可能会出现轻微的缺陷，但这是基本的想法。

Answer 13

我是怎么做到的：

final int numberOfSpaces = 22;
final char[] spaceArray = new char[numberOfSpaces];
Arrays.fill(spaces, ' ');

现在将其添加到您的StringBuilder

stringBuilder.append(spaceArray);

或String

final String spaces = String.valueOf(spaceArray);

Answer 14

为了了解速度惩罚，我测试了两个版本，一个是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);
}

（注意主要功能中的循环是踢JIT）

结果如下：

elapsed repeat: 65899
elapsed repeatSB: 305171

巨大的差异

Answer 15

这是一个简单的方法..

for(int i=0;i<n;i++)
{
  yourString = yourString + "what you want to append continiously";
}

Java：String - 添加字符n次

15 个答案: