C'è un modo in Java per creare una stringa con un numero specificato di un carattere specificato? Nel mio caso, avrei bisogno di creare una stringa con 10 spazi. Il mio codice attuale è:

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

C'è un modo migliore per realizzare la stessa cosa. In particolare, vorrei qualcosa di veloce (in termini di esecuzione).

Il ciclo for sarà ottimizzato dal compilatore. In casi come il tuo non devi preoccuparti dell'ottimizzazione da solo. Fidati del compilatore.

A proposito, se c'è un modo per creare una stringa con n caratteri spaziali, allora è codificato nello stesso modo come hai appena fatto.

Probabilmente il codice più breve che utilizza l' StringAPI, esclusivamente:

String space10 = new String(new char[10]).replace('\0', ' ');

System.out.println("[" + space10 + "]");
// prints "[          ]"

Come metodo, senza istanziare direttamente 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', ' ' );
}

Richiamare usando:

System.out.printf( "[%s]%n", spaces( 10 ) );

Hmm ora che ci penso, forse Arrays.fill:

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

Ovviamente, suppongo che il fillmetodo faccia la stessa cosa del tuo codice, quindi probabilmente funzionerà allo stesso modo, ma almeno questo è un minor numero di righe.

Consiglio vivamente di non scrivere il ciclo a mano. Lo farai più e più volte nel corso della tua carriera di programmatore. Le persone che leggono il tuo codice, incluso te, devono sempre investire tempo, anche se solo pochi secondi, per digerire il significato del loop.

Invece riutilizza una delle librerie disponibili che forniscono codice che fa esattamente questo come StringUtils.repeatda Apache Commons Lang :

StringUtils.repeat(' ', length);

In questo modo, inoltre, non devi preoccuparti delle prestazioni, quindi tutti i dettagli cruenti di StringBuilder, le ottimizzazioni del compilatore ecc. Sono nascosti. Se la funzione si rivelasse così lenta, sarebbe un bug della libreria.

Con Java 11 diventa ancora più semplice:

" ".repeat(length);

In Java 8 puoi usare String.join:

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

Se vuoi solo spazi, che ne dici di:

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

che si tradurrà in abs (n) spazi;

da Java 11 :

" ".repeat(10);

da Java 8 :

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

dove:

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

Da Java 11 puoi semplicemente usare String.repeat(count)per risolvere il tuo problema.

Restituisce una stringa il cui valore è la concatenazione di questa stringa ripetuti countvolte.

Se questa stringa è vuota o countè zero, viene restituita la stringa vuota.

Quindi, invece di un ciclo, il codice dovrebbe apparire così:

" ".repeat(length);

Penso che questo sia il codice meno possibile, utilizza la classe Guava Joiner:

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

È possibile utilizzare la String.formatfunzione standard per generare N spazi. Per esempio:

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

Crea una stringa con 5 spazi.

o

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

Crea una stringa di 15 barre spaziali.

Se si desidera ripetere un altro simbolo, è necessario sostituire gli spazi con il simbolo desiderato:

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

Produzione:

#######

Il mio contributo si basa sull'algoritmo per una rapida esponenziazione.

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

Ho testato l'algoritmo con altri due approcci:

• Regolare per il ciclo usando String.concat()per concatenare la stringa
• Regolare per il loop usando a StringBuilder

Codice di prova (concatenazione usando un ciclo for e String.concat()diventa più lento per grandi n, quindi l'ho lasciato fuori dopo la quinta iterazione).

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

risultati:

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

Conclusione:

• Per grandi n- utilizzare l'approccio ricorsivo
• Per piccoli n- per loop ha una velocità sufficiente

Cosa ne pensi di questo?

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

Considerando che abbiamo:

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 (utilizzando Stream)

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

Java 8 (utilizzo di nCopies)

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

RandomStringUtils ha una disposizione per creare una stringa da una determinata dimensione di input. Non posso commentare la velocità, ma è una fodera.

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

crea un output

\ T \ t \ t \ t \ t

preferibile se non vuoi vedere \ 0 nel tuo codice.

Usa StringUtils: StringUtils.repeat ('', 10)

Nella maggior parte dei casi hai bisogno solo di stringhe fino a una certa lunghezza, diciamo 100 spazi. È possibile preparare una matrice di stringhe in cui il numero di indice è uguale alla dimensione della stringa riempita di spazio e cercare la stringa, se la lunghezza richiesta è entro i limiti o crearla su richiesta se è al di fuori del limite.

La soluzione più breve con Guava:

Strings.repeat(" ", len)

Via Modo semplice per ripetere una stringa in Java .

Basta sostituire StringBuffer con StringBuilder . Difficile da battere.

Se la tua lunghezza è un numero elevato, potresti implementare qualche autoappendice più efficiente (ma più goffa), duplicando la lunghezza in ogni iterazione:

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

Inoltre, potresti provare l' Arrays.fill()approccio ( la risposta di FrustratedWithFormsDesigner ).

Puoi sostituirlo StringBuffercon StringBuilder(quest'ultimo non è sincronizzato, potrebbe essere più veloce in una singola app thread)

E puoi creare l' StringBuilderistanza una volta, invece di crearla ogni volta che ne hai bisogno.

Qualcosa come questo:

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

  }

E usalo in questo modo:

 BuildString createA = new BuildString();
 String empty = createA.stringOf( ' ', 10 );

Se tieni la tua createAcome variabile di istanza, puoi risparmiare tempo nella creazione di istanze.

Questo non è sicuro per i thread, se si dispone di più thread, ogni thread dovrebbe avere la propria copia.

Per buone prestazioni, combina le risposte di aznilamir e di 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 );
    }
}

Regola le dimensioni in BLANKSbase alle tue esigenze. La mia BLANKSstringa specifica ha una lunghezza di circa 200 caratteri.

Avere un metodo come questo. Questo accoda gli spazi richiesti alla fine del dato Stringper fare un dato Stringalla lunghezza di lunghezza specifica.

public static String fillSpaces (String str) {

    // the spaces string should contain spaces exceeding the max needed
    String spaces = "                                                   ";
    return str + spaces.substring(str.length());
}

Vuoi che String abbia dimensioni fisse, quindi pad o troncare, per tabulare i dati ...

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|

Ottimo riferimento qui .

Questo ha funzionato per me senza utilizzare alcuna libreria esterna in Java 8

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

E l'output è

testtesttest

int c = 10; Spazi stringa = String.format ("%" + c + "c", ''); questo risolverà il tuo problema.

È anche possibile utilizzare un metodo semplice come di seguito

public static String padString(String str, int leng,char chr) {
        for (int i = str.length(); i <= leng; i++)
            str += chr;
        return str;
    }

cosa ne pensi di questo?

public String fillSpaces(int len) {
    /* the spaces string should contain spaces exceeding the max needed */  
    String spaces = "                                                   ";
    return spaces.substring(0,len);
}

EDIT: ho scritto un semplice codice per testare il concetto e qui quello che ho trovato.

Metodo 1: aggiunta di uno spazio singolo in un ciclo:

  public String execLoopSingleSpace(int len){
    StringBuilder sb = new StringBuilder();

    for(int i=0; i < len; i++) {
        sb.append(' ');
    }

    return sb.toString();
  }

Metodo 2: aggiungere 100 spazi e loop, quindi sottostringa:

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

Il risultato ottengo creando 12.345.678 spazi:

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

e per 10.000.000 di spazi:

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

la combinazione di allocazione diretta e iterazione richiede sempre meno tempo, in media 60 ms in meno quando si creano spazi enormi. Per taglie più piccole, entrambi i risultati sono trascurabili.

Ma per favore continua a commentare :-)

Non conosco alcun metodo integrato per quello che stai chiedendo. Tuttavia, per una lunghezza fissa ridotta come 10, il metodo dovrebbe essere molto veloce.