¿Hay alguna manera en Java para crear una cadena con un número específico de un carácter específico? En mi caso, necesitaría crear una cadena con 10 espacios. Mi código actual es:

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

¿Hay una mejor manera de lograr lo mismo? En particular, me gustaría algo que sea rápido (en términos de ejecución).

El compilador optimizará el bucle for. En casos como el suyo, no necesita preocuparse por la optimización por su cuenta. Confía en el compilador.

Por cierto, si hay una manera de crear una cadena con n caracteres de espacio, entonces se codifica de la misma manera que lo hizo.

Probablemente el código más corto que utiliza la StringAPI, exclusivamente:

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

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

Como método, sin instanciar directamente 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', ' ' );
}

Invocar usando:

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

Hmm, ahora que lo pienso, tal vez Arrays.fill:

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

Por supuesto, supongo que el fillmétodo hace lo mismo que su código, por lo que probablemente funcionará de la misma manera, pero al menos son menos líneas.

Recomiendo no escribir el bucle a mano. Lo harás una y otra vez durante el curso de tu carrera de programación. Las personas que leen su código, eso lo incluye a usted, siempre tienen que invertir tiempo, incluso si son solo unos segundos, para digerir el significado del bucle.

En su lugar, reutilice una de las bibliotecas disponibles que proporcionan código que hace exactamente eso StringUtils.repeatdesde Apache Commons Lang :

StringUtils.repeat(' ', length);

De esa manera, tampoco tiene que preocuparse por el rendimiento, por lo que todos los detalles sangrientos StringBuilder, las optimizaciones del compilador, etc. están ocultos. Si la función resultara lenta, sería un error de la biblioteca.

Con Java 11 se vuelve aún más fácil:

" ".repeat(length);

En Java 8 puedes usar String.join:

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

Si solo quieres espacios, entonces ¿qué tal:

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

lo que dará como resultado espacios abs (n);

desde Java 11 :

" ".repeat(10);

desde Java 8 :

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

dónde:

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

Desde Java 11 simplemente puede usar String.repeat(count)para resolver su problema.

Devuelve una cadena cuyo valor es la concatenación de esta cadena repetida count veces.

Si esta cadena está vacía o countes cero, se devuelve la cadena vacía.

Entonces, en lugar de un bucle, su código se vería así:

" ".repeat(length);

Creo que este es el menor código posible, usa la clase Guava Joiner:

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

Puede usar la String.formatfunción estándar para generar N espacios. Por ejemplo:

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

Hace una cuerda con 5 espacios.

o

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

Hace una cadena de 15 barras espaciales.

Si desea que se repita otro símbolo, debe reemplazar los espacios con su símbolo deseado:

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

Salida:

#######

Mi contribución basada en el algoritmo de exponenciación rápida.

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

Probé el algoritmo contra otros dos enfoques:

• Regular para bucle usando String.concat()para concatenar una cadena
• Regular para bucle usando un StringBuilder

Código de prueba (concatenación usando un bucle for y se String.concat()vuelve lento para grande n, así que lo dejé fuera después de la quinta iteración).

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

Resultados:

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

Conclusión:

• Para grandes n: use el enfoque recursivo
• Para pequeño n: para el bucle tiene suficiente velocidad

¿Qué tal esto?

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

Considerando que tenemos:

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 (Uso de Stream)

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

Java 8 (usando nCopies)

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

RandomStringUtils tiene una provisión para crear una cadena a partir del tamaño de entrada dado. No puedo comentar sobre la velocidad, pero es un trazador de líneas.

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

crea una salida

\ t \ t \ t \ t \ t

preferible si no desea ver \ 0 en su código.

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

En la mayoría de los casos, solo necesita cadenas hasta una longitud determinada, digamos 100 espacios. Puede preparar una matriz de cadenas donde el número de índice es igual al tamaño de la cadena llena de espacio y buscar la cadena, si la longitud requerida está dentro de los límites o crearla a pedido si está fuera del límite.

La solución más corta con guayaba:

Strings.repeat(" ", len)

Vía Forma simple de repetir una cadena en java .

Simplemente reemplace su StringBuffer con un StringBuilder . Difícil de superar eso.

Si su longitud es un número grande, podría implementar algunos autoanexos más eficientes (pero más torpes), duplicando la longitud en cada iteración:

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

Además, puede probar el Arrays.fill()enfoque ( la respuesta de FrustratedWithFormsDesigner ).

Puedes reemplazar StringBufferconStringBuilder (este último no está sincronizado, puede ser más rápido en una aplicación de subproceso único)

Y puede crear la StringBuilderinstancia una vez, en lugar de crearla cada vez que la necesite.

Algo como esto:

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

  }

Y úsalo así:

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

Si mantiene su createAvariable de instancia, puede ahorrar tiempo creando instancias.

Esto no es seguro para subprocesos, si tiene varios subprocesos, cada subproceso debe tener su propia copia.

Para un buen rendimiento, combine las respuestas de aznilamir y de 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 );
    }
}

Ajuste el tamaño de BLANKSacuerdo con sus requisitos. Mi BLANKScadena específica tiene aproximadamente 200 caracteres de longitud.

Tener un método como este. Esto agrega los espacios requeridos al final de lo dado Stringpara hacer una Stringlongitud determinada de una longitud específica.

public static String fillSpaces (String str) {

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

Desea que la cadena sea de tamaño fijo, para que pueda rellenar o truncar, para tabular datos ...

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|

Excelente referencia aquí .

Esto funcionó para mí sin usar ninguna biblioteca externa en Java 8

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

Y la salida es

testtesttest

int c = 10; Espacios de cadena = String.format ("%" + c + "c", ''); Esto resolverá su problema.

También se puede usar un método simple como el siguiente

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

¿Qué tal esto?

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

EDITAR: he escrito un código simple para probar el concepto y aquí lo que encontré.

Método 1: agregar espacio único en un bucle:

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

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

    return sb.toString();
  }

Método 2: agregue 100 espacios y bucle, luego subcadena:

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

El resultado que obtengo al crear 12,345,678 espacios:

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

y para 10,000,000 espacios:

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 combinación de asignación directa e iteración siempre lleva menos tiempo, en promedio 60 ms menos al crear espacios enormes. Para tamaños más pequeños, ambos resultados son insignificantes.

Pero por favor continúe comentando :-)

No conozco ningún método integrado para lo que estás preguntando. Sin embargo, para una longitud fija pequeña como 10, su método debería ser bastante rápido.