Цикл for будет оптимизирован компилятором. В таких случаях, как ваш, вам не нужно самостоятельно заботиться об оптимизации. Доверьтесь компилятору.

Кстати, если есть способ создать строку с n пробелами, то она закодирована так же, как и вы.

Вероятно, самый короткий код с использованием 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 ) );

Я настоятельно рекомендую не писать цикл вручную. Вы будете делать это снова и снова в течение вашей карьеры программиста. Люди, читающие ваш код - включая вас - всегда должны тратить время, даже если это всего несколько секунд, чтобы усвоить смысл цикла.

Вместо этого повторно используйте одну из доступных библиотек, предоставляющую код, который делает то же самое, например StringUtils.repeatfrom Язык Apache Commons:

StringUtils.repeat(' ', length);

Таким образом, вам также не нужно беспокоиться о производительности, поэтому все кровавые детали StringBuilder, оптимизации компилятора и т. Д. Будут скрыты. Если бы функция оказалась такой медленной, это было бы ошибкой библиотеки.

С Java 11 становится еще проще:

" ".repeat(length);

Хм, теперь, когда я думаю об этом, возможно, _ 1_:

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

Конечно, я предполагаю, что метод fill делает то же самое, что и ваш код, поэтому он, вероятно, будет работать примерно так же, но, по крайней мере, это меньше строк.

В Java 8 вы можете использовать String.join:

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

начиная с 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;

Если вам нужны только пробелы, то как насчет:

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

что приведет к появлению пробелов abs (n);

Начиная с Java 11, вы можете просто использовать _ 1_, чтобы решить вашу проблему.

Возвращает строку, значение которой является объединением этой строки, повторенной count раз.

Если эта строка пуста или count равно нулю, возвращается пустая строка.

Таким образом, вместо цикла ваш код будет выглядеть так:

" ".repeat(length);

Я думаю, что это меньше кода, чем возможно, он использует класс Guava Joiner:

Столяр .on (""). join (Collections.nCopies (10, ""));

Вы можете использовать стандартную функцию String.format для генерации N пробелов. Например:

String.format("%5c", ' ');

Делает строку с 5 пробелами.

or

int count = 15;
String fifteenSpacebars = String.format("%" + count + "c", ' ');

Делает строку из 15 пробелов.

Если вы хотите, чтобы повторялся другой символ, вы должны заменить пробелы желаемым символом:

int count = 7;
char mySymbol = '#';
System.out.println(String.format("%" + count + "c", ' ').replaceAll("\\ ", "\\" + mySymbol));

Вывод:

#######

Мой вклад основан на алгоритме быстрого возведения в степень.

/**
 * 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));
}

Я протестировал алгоритм против двух других подходов:

• Обычный цикл for с использованием String.concat() для объединения строки
• Обычный цикл for с использованием 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 - для цикла достаточная скорость

Как насчет этого?

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

Учитывая, что у нас есть:

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)

Java 8 (с использованием потока)

String resultOne = IntStream.range(0,n)
   .mapToObj(i->c).collect(Collectors.joining(EMPTY_STRING)); // cccc

Java 8 (с использованием nCopies)

String resultTwo = String.join(EMPTY_STRING, Collections.nCopies(n, c)); //cccc

RandomStringUtils имеет положение для создания строки из заданного размера ввода. Не могу прокомментировать скорость, но это один лайнер.

RandomStringUtils.random(5,"\t");

создает вывод

\t\t\t\t\t

предпочтительно, если вы не хотите видеть в своем коде \ 0.

Используйте StringUtils: StringUtils.repeat ('', 10)

Кратчайшее решение с Guava:

Strings.repeat(" ", len)

С помощью Простой способ повторить строку в java.

Это сработало для меня без использования каких-либо внешних библиотек в Java 8

String sampleText = "test"
int n = 3;
String output = String.join("", Collections.nCopies(n, sampleText));
System.out.println(output);

И на выходе

testtesttest

int c = 10; Строковые пробелы = String.format ("%" + c + "c", ''); это решит вашу проблему.

В большинстве случаев вам нужны только строки до определенной длины, скажем, 100 пробелов. Вы можете подготовить массив строк, в котором номер индекса равен размеру заполненной пробелами строки, и выполнить поиск строки, если требуемая длина находится в установленных пределах, или создать ее по запросу, если она находится за пределами границ.

Просто замените свой StringBuffer на StringBuilder. Трудно превзойти это.

Если у вас большая длина, вы можете реализовать более эффективное (но более неуклюжее) самодобавление, дублируя длину на каждой итерации:

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

Вы можете заменить 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 как переменную экземпляра, вы можете сэкономить время на создании экземпляров.

Это не потокобезопасно, если у вас несколько потоков, у каждого потока должна быть собственная копия.

Для хорошей производительности объедините ответы из 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 символов.

У вас есть такой метод. Это добавляет необходимые пробелы в конце заданного 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());
}

Хотите, чтобы строка имела фиксированный размер, поэтому вы либо заполняете, либо усекаете для табулирования данных ...

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|

Отличная ссылка здесь.

Также можно использовать простой метод, подобный приведенному ниже.

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

РЕДАКТИРОВАТЬ: Я написал простой код для проверки концепции и вот что я нашел.

Метод 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

сочетание прямого выделения и итерации всегда занимает меньше времени, в среднем на 60 мс меньше при создании огромных пространств. Для меньших размеров оба результата незначительны.

Но продолжайте комментировать :-)

Я не знаю встроенного метода того, о чем вы спрашиваете. Однако для небольшой фиксированной длины, такой как 10, ваш метод должен быть достаточно быстрым.