我创建了一个递归方法，可以做你想做的事情。。随便用这个。。。

public String repeat(String str, int count) {
    return count > 0 ?  repeat(str, count -1) + str: "";
}

我有相同的答案，我可以乘字符串在java中重复序列？

不是最短的，但（我认为）最快的方法是使用stringbuilder：

/**
   * Repeat a String as many times you need.
   *
   * @param i - Number of Repeating the String.
   * @param s - The String wich you want repeated.
   * @return The string n - times.
   */
  public static String repeate(int i, String s) {
    StringBuilder sb = new StringBuilder();
    for (int j = 0; j < i; j++)
      sb.append(s);
    return sb.toString();
  }

试试这个：

public static char[] myABCs = {'a', 'b', 'c'};
public static int numInput;
static Scanner in = new Scanner(System.in);

public static void main(String[] args) {
    System.out.print("Enter Number of Times to repeat: ");
    numInput = in.nextInt();
    repeatArray(numInput);
}

public static int repeatArray(int y) {
    for (int a = 0; a < y; a++) {
        for (int b = 0; b < myABCs.length; b++) {
            System.out.print(myABCs[b]);                
        }
        System.out.print(" ");
    }
    return y;
}

java 8的 String.join 提供了一种整洁的方法来与 Collections.nCopies :

// say hello 100 times
System.out.println(String.join("", Collections.nCopies(100, "hello")));

在java-8中，还可以使用 Stream.generate .

import static java.util.stream.Collectors.joining;
...
String repeated = Stream.generate(() -> "abc").limit(3).collect(joining()); //"abcabcabc"

如果需要，您可以用简单的实用方法 Package 它：

public static String repeat(String str, int times) {
   return Stream.generate(() -> str).limit(times).collect(joining());
}

如果你关心的是速度，那么你应该使用尽可能少的内存复制。因此需要处理字符数组。

public static String repeatString(String what, int howmany) {
    char[] pattern = what.toCharArray();
    char[] res = new char[howmany * pattern.length];
    int length = pattern.length;
    for (int i = 0; i < howmany; i++)
        System.arraycopy(pattern, 0, res, i * length, length);
    return new String(res);
}

为了测试速度，使用stirngbuilder的类似优化方法如下：

public static String repeatStringSB(String what, int howmany) {
    StringBuilder out = new StringBuilder(what.length() * 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 = repeatString("123", 100000);
        res = repeatStringSB("123", 100000);
    }

    time = System.nanoTime();
    res = repeatString("123", 1000000);
    time = System.nanoTime() - time;
    System.out.println("elapsed repeatString: " + time);

    time = System.nanoTime();
    res = repeatStringSB("123", 1000000);
    time = System.nanoTime() - time;
    System.out.println("elapsed repeatStringSB: " + time);

}

下面是我系统的运行结果：

elapsed repeatString: 6006571
elapsed repeatStringSB: 9064937

注意，对循环的测试是在jit中启动并获得最佳结果。

为了便于阅读和携带：

public String repeat(String str, int count){
    if(count <= 0) {return "";}
    return new String(new char[count]).replace("\0", str);
}

使用美元很简单，只需键入：

@Test
public void repeatString() {
    String string = "abc";
    assertThat($(string).repeat(3).toString(), is("abcabcabc"));
}

对数组、列表、集合等也同样适用

这比你的问题包含的字符少

public static String repeat(String s, int n) {
    if(s == null) {
        return null;
    }
    final StringBuilder sb = new StringBuilder(s.length() * n);
    for(int i = 0; i < n; i++) {
        sb.append(s);
    }
    return sb.toString();
}

如果您担心性能，只需在循环中使用stringbuilder，并在循环退出时执行.tostring（）。见鬼，编写自己的util类并重用它。最多5行代码。

如果你像我一样，想用谷歌Guava而不是Apache公地。可以在guava strings类中使用repeat方法。

Strings.repeat("-", 60);

使用递归，可以执行以下操作（使用三元运算符，最多一行）：

public static final String repeat(String string, long number) {
    return number == 1 ? string : (number % 2 == 0 ? repeat(string + string, number / 2) : string + repeat(string + string, (number - 1) / 2));
}

我知道，这是丑陋的，可能没有效率，但它是一行！

简单的单线解决方案：
需要java 8

Collections.nCopies( 3, "abc" ).stream().collect( Collectors.joining() );

根据fortran的回答，这是一个使用stringbuilder的递归版本：

public static void repeat(StringBuilder stringBuilder, String s, int times) {
    if (times > 0) {
        repeat(stringBuilder.append(s), s, times - 1);
    }
}

public static String repeat(String s, int times) {
    StringBuilder stringBuilder = new StringBuilder(s.length() * times);
    repeat(stringBuilder, s, times);
    return stringBuilder.toString();
}

commons lang stringutils.repeat（）
用法：

String str = "abc";
String repeated = StringUtils.repeat(str, 3);

repeated.equals("abcabcabc");