Créer une chaîne de n caractères

Probablement les plus brefs code à l'aide de la String API, exclusivement:

String space10 = new String(new char[10]).replace('
String space10 = new String(new char[10]).replace('\0', ' ');
System.out.println("[" + space10 + "]");
//prints "[          ]"
', ' ');

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

Comme une méthode, sans en faire directement l'instanciation de 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( '
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', ' ' );
}
', ' ' );
}

Appeler à l'aide:

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

Je vous suggère fortement de ne pas écrire la boucle à la main.
Vous pourrez le faire plus et plus encore, au cours de votre programmation de carrière.
Les gens de la lecture de votre code - vous de toujours avoir à investir du temps, même si ce sont juste quelques secondes, pour digérer le sens de la boucle.

Au lieu réutilisation l'une des bibliothèques de la fourniture du code qui ne fonctionne tout simplement que, comme StringUtils.repeatde Apache Commons Lang:

StringUtils.repeat(' ', length);

De cette façon, vous n'avez pas à vous soucier de la performance, ainsi tous les détails sanglants de la StringBuilder, optimisations du Compilateur, etc. sont cachés.
Si la fonction ferait que ralentir ce serait un bug de la bibliothèque.

Avec Java 11 il devient encore plus facile:

" ".repeat(length);

Si vous ne souhaitez que des espaces, alors que diriez-vous:

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

qui se traduira en abs(n) des espaces;

Ma contribution basée sur l'algorithme d'exponentiation rapide.

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

J'ai testé l'algorithme à l'encontre de deux autres approches:

• Régulière pour la boucle à l'aide de String.concat() pour concaténer des chaînes
• Régulière pour la boucle à l'aide d'un StringBuilder

Le code de Test (concaténation à l'aide d'une boucle for et String.concat() devient lent pour les grandes n, donc je l'ai laissée après la 5ème itération).

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

Résultats:

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

Conclusion:

• Pour les grandes n - utiliser l'approche récursive
• Pour les petites n - pour la boucle a une vitesse suffisante

Compte tenu que nous avons:

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 (À L'Aide De Flux)

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

Java 8 (à l'Aide de nCopies)

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

RandomStringUtils a une disposition pour créer une chaîne de compte tenu de la taille de l'image.
Cant commentaire sur la vitesse, mais c'est un liner.

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

crée une sortie

\t\t\t\t\t

préférable si vous ne voulez pas voir \0 dans votre code.

Dans la plupart des cas, vous avez seulement besoin de Chaînes jusqu'à un certains de longueur, de 100 places. Vous pouvez vous préparer un tableau de Chaînes de caractères où le numéro d'index est égal à la taille de l'espace rempli de chaîne et de recherche de la chaîne, si la longueur est dans les limites ou le créer à la demande, si c'est en dehors de la frontière.

Il suffit de remplacer votre StringBuffer avec un StringBuilder. Dur à battre.

Si votre longueur est un grand nombre, vous pourriez mettre en œuvre certaines sont plus efficaces
(mais plus maladroit) auto-appendding, de dupliquer la longueur de chaque itération:

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

Aussi, vous pouvez essayer le Arrays.fill() l'approche (FrustratedWithFormsDesigner's réponse).

Pour une bonne performance, combiner les réponses de aznilamir et 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 );
    }
}

Ajuster la taille de BLANKS en fonction de vos besoins. Mon BLANKS chaîne est d'environ 200 caractères de longueur.

Une méthode simple comme ci-dessous peut également être utilisé

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

Je ne connais pas de méthode intégrée pour ce que vous demandez sur. Cependant, pour une petite longueur fixe de 10, votre méthode doit être beaucoup rapide.