指定された数の指定された文字で文字列を作成する方法はありますか？私の場合、10スペースの文字列を作成する必要があります。私の現在のコードは：

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

同じことを達成するためのより良い方法はありますか？特に、（実行に関して）高速なものが欲しいです。

forループはコンパイラーによって最適化されます。このような場合、自分で最適化について気にする必要はありません。コンパイラを信頼します。

ところで、n個のスペース文字を含む文字列を作成する方法がある場合は、以前と同じようにコーディングします。

おそらく、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 ) );

うーん、今考えてみると、たぶんArrays.fill：

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

もちろん、私はfillメソッドがコードと同じことをすることを想定しているので、ほぼ同じように実行されますが、少なくともこれは行数が少なくなります。

ループを手動で記述しないことを強くお勧めします。あなたはプログラミングのキャリアの中で何度もそれを繰り返します。あなたを含むあなたのコードを読む人々-たとえそれがほんの数秒であっても、ループの意味を消化するために常に時間を費やす必要があります。

代わりに、Apache Commons Langのようにそれを行うコードを提供する利用可能なライブラリの1つを再利用します。StringUtils.repeat

StringUtils.repeat(' ', length);

そうすれば、パフォーマンスについて気にする必要がないため、、StringBuilderコンパイラーの最適化などのすべての悲惨な詳細が隠されます。関数が遅くなる場合は、ライブラリのバグです。

Javaの11それがさらに容易になり：

" ".repeat(length);

Java 8では次を使用できますString.join。

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

スペースのみが必要な場合は、次のようにします。

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

これにより、abs（n）スペースが生成されます。

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;

Java 11以降ではString.repeat(count)、問題を解決するために簡単に使用できます。

値がこの文字列の繰り返しの連結である文字列を返しますcount。

この文字列が空またはcountゼロの場合、空の文字列が返されます。

したがって、ループの代わりに、コードは次のようになります。

" ".repeat(length);

私はこれが可能なコードが少ないと思います、それはGuava Joinerクラスを使用します：

ジョイナー .on（ ""）。join（Collections.nCopies（10、 ""））;

String.formatN個のスペースを生成するための標準関数を使用できます。例えば：

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

出力：

#######

高速累乗のアルゴリズムに基づく私の貢献。

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

他の2つのアプローチに対してアルゴリズムをテストしました。

• String.concat()文字列を連結するために使用する通常のforループ
• を使用した通常のforループ StringBuilder

テストコード（forループを使用した連結でString.concat()、largeの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ループは十分な速度があります

これはどう？

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）

ほとんどの場合、必要なのは特定の長さ、たとえば100スペースまでの文字列だけです。必要な長さが制限内にある場合は、インデックス番号がスペースで満たされた文字列のサイズと等しい文字列の配列を準備し、文字列を検索するか、境界の外側にある場合はオンデマンドで作成できます。

Guavaを使用した最短のソリューション：

Strings.repeat(" ", len)

経由して簡単な方法Javaで文字列を繰り返します。

ただであなたの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()アプローチを試すかもしれません（FrustratedWithFormsDesignerの答え）。

あなたは置き換えることができStringBufferてStringBuilder（後者は同期されていない、より高速なシングルスレッドのアプリケーションであってもよいです）

またStringBuilder、必要になるたびにインスタンスを作成する代わりに、インスタンスを1回作成することもできます。

このようなもの：

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|

ここで優れたリファレンス。

これは、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"、 ''）; これで問題が解決します。

以下のような簡単な方法も使用できます

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のような小さな固定長の場合、メソッドはかなり高速になるはずです。