Je suis à la recherche d'une méthode ou d'un opérateur commun simple qui me permet de répéter quelques fois n String . Je sais que je pourrais écrire ceci en utilisant une boucle for, mais je souhaite éviter les boucles for chaque fois que nécessaire et une méthode directe simple devrait exister quelque part.

String str = "abc";
String repeated = str.repeat(3);

repeated.equals("abcabcabc");

Relative à:

répéter la chaîne javascript Créer NSString en répétant une autre chaîne un certain nombre de fois

Édité

J'essaye d'éviter les boucles quand elles ne sont pas complètement nécessaires car:

1. Ils ajoutent au nombre de lignes de code même s'ils sont cachés dans une autre fonction.

2. Quelqu'un qui lit mon code doit comprendre ce que je fais dans cette boucle for. Même s'il est commenté et a des noms de variables significatifs, ils doivent toujours s'assurer qu'il ne fait rien de «intelligent».

3. Les programmeurs adorent mettre des choses intelligentes dans les boucles, même si je l'écris pour "ne faire que ce qu'il est censé faire", cela n'empêche pas quelqu'un de venir et d'ajouter quelques "correctifs" supplémentaires.

4. Ils sont très souvent faciles à se tromper. Pour les boucles impliquant des index, les bugs ont tendance à se produire.

5. Pour les boucles, réutilisez souvent les mêmes variables, ce qui augmente les chances de trouver des bogues de portée très difficiles.

6. Pour les boucles, augmentez le nombre d'endroits qu'un chasseur de bogues doit rechercher.

String::repeat

". ".repeat( 7 )  // Seven period-with-space pairs: . . . . . . . 

Nouveau dans Java 11 est la méthode String::repeatqui fait exactement ce que vous avez demandé:

String str = "abc";
String repeated = str.repeat(3);
repeated.equals("abcabcabc");

Son Javadoc dit:

/**
 * Returns a string whose value is the concatenation of this
 * string repeated {@code count} times.
 * <p>
 * If this string is empty or count is zero then the empty
 * string is returned.
 *
 * @param count number of times to repeat
 *
 * @return A string composed of this string repeated
 * {@code count} times or the empty string if this
 * string is empty or count is zero
 *
 * @throws IllegalArgumentException if the {@code count} is
 * negative.
 *
 * @since 11
 */ 

Voici la version la plus courte (Java 1.5+ requis):

repeated = new String(new char[n]).replace("\0", s);

Où nest le nombre de répétitions de la chaîne et sla chaîne à répéter.

Aucune importation ou bibliothèque nécessaire.

Si vous utilisez Java <= 7 , c'est aussi "concis" que possible:

// create a string made up of n copies of string s
String.format("%0" + n + "d", 0).replace("0", s);

En Java 8 et supérieur, il existe un moyen plus lisible:

// create a string made up of n copies of string s
String.join("", Collections.nCopies(n, s));

Enfin, pour Java 11 et supérieur, il existe une nouvelle repeat​(int count)méthode spécialement pour cela ( lien )

"abc".repeat(12);

Alternativement, si votre projet utilise des bibliothèques java, il y a plus d'options.

Pour Apache Commons :

StringUtils.repeat("abc", 12);

Pour Google Guava :

Strings.repeat("abc", 12);

Commons Lang StringUtils.repeat ()

Usage:

String str = "abc";
String repeated = StringUtils.repeat(str, 3);

repeated.equals("abcabcabc");

Java 8 String.joinfournit une manière ordonnée de le faire en conjonction avec Collections.nCopies:

// say hello 100 times
System.out.println(String.join("", Collections.nCopies(100, "hello")));

Voici un moyen de le faire en utilisant uniquement des fonctions String standard et aucune boucle explicite:

// create a string made up of  n  copies of  s
repeated = String.format(String.format("%%%ds", n), " ").replace(" ",s);

Si vous êtes comme moi et que vous souhaitez utiliser Google Guava et non Apache Commons. Vous pouvez utiliser la méthode repeat dans la classe Guava Strings.

Strings.repeat("-", 60);

Avec java-8, vous pouvez également utiliser Stream.generate.

import static java.util.stream.Collectors.joining;
...
String repeated = Stream.generate(() -> "abc").limit(3).collect(joining()); //"abcabcabc"

et vous pouvez l'envelopper dans une méthode utilitaire simple si nécessaire:

public static String repeat(String str, int times) {
   return Stream.generate(() -> str).limit(times).collect(joining());
}

Vous voulez donc éviter les boucles?

Ici vous l'avez:

public static String repeat(String s, int times) {
    if (times <= 0) return "";
    else return s + repeat(s, times-1);
}

(bien sûr, je sais que c'est moche et inefficace, mais il n'a pas de boucles :-p)

Vous le voulez plus simple et plus joli? utilisez jython:

s * 3

Edit : optimisons-le un peu :-D

public static String repeat(String s, int times) {
   if (times <= 0) return "";
   else if (times % 2 == 0) return repeat(s+s, times/2);
   else return s + repeat(s+s, times/2);
}

Edit2 : J'ai fait un benchmark rapide et sale pour les 4 principales alternatives, mais je n'ai pas le temps de l'exécuter plusieurs fois pour obtenir les moyens et tracer les temps pour plusieurs entrées ... Alors voici le code si quelqu'un veut pour l'essayer:

public class Repeat {
    public static void main(String[] args)  {
        int n = Integer.parseInt(args[0]);
        String s = args[1];
        int l = s.length();
        long start, end;

        start = System.currentTimeMillis();
        for (int i = 0; i < n; i++) {
            if(repeatLog2(s,i).length()!=i*l) throw new RuntimeException();
        }
        end = System.currentTimeMillis();
        System.out.println("RecLog2Concat: " + (end-start) + "ms");

        start = System.currentTimeMillis();
        for (int i = 0; i < n; i++) {
            if(repeatR(s,i).length()!=i*l) throw new RuntimeException();
        }               
        end = System.currentTimeMillis();
        System.out.println("RecLinConcat: " + (end-start) + "ms");

        start = System.currentTimeMillis();
        for (int i = 0; i < n; i++) {
            if(repeatIc(s,i).length()!=i*l) throw new RuntimeException();
        }
        end = System.currentTimeMillis();
        System.out.println("IterConcat: " + (end-start) + "ms");

        start = System.currentTimeMillis();
        for (int i = 0; i < n; i++) {
            if(repeatSb(s,i).length()!=i*l) throw new RuntimeException();
        }
        end = System.currentTimeMillis();
        System.out.println("IterStrB: " + (end-start) + "ms");
    }

    public static String repeatLog2(String s, int times) {
        if (times <= 0) {
            return "";
        }
        else if (times % 2 == 0) {
            return repeatLog2(s+s, times/2);
        }
        else {
           return s + repeatLog2(s+s, times/2);
        }
    }

    public static String repeatR(String s, int times) {
        if (times <= 0) {
            return "";
        }
        else {
            return s + repeatR(s, times-1);
        }
    }

    public static String repeatIc(String s, int times) {
        String tmp = "";
        for (int i = 0; i < times; i++) {
            tmp += s;
        }
        return tmp;
    }

    public static String repeatSb(String s, int n) {
        final StringBuilder sb = new StringBuilder();
        for(int i = 0; i < n; i++) {
            sb.append(s);
        }
        return sb.toString();
    }
}

Il prend 2 arguments, le premier est le nombre d'itérations (chaque fonction s'exécute avec des temps de répétition arg de 1..n) et le second est la chaîne à répéter.

Jusqu'à présent, une inspection rapide des temps d'exécution avec différentes entrées laisse le classement quelque chose comme ça (de mieux en pire):

1. Ajout de StringBuilder itératif (1x).
2. Appels récursifs de concaténation log2 (~ 3x).
3. Invocations linéaires de concaténation récursive (~ 30x).
4. Concaténation itérative linéaire (~ 45x).

Je n'aurais jamais deviné que la fonction récursive était plus rapide que la forboucle: -o

Amusez-vous (ctional xD).

Cela contient moins de caractères que votre question

public static String repeat(String s, int n) {
    if(s == null) {
        return null;
    }
    final StringBuilder sb = new StringBuilder(s.length() * n);
    for(int i = 0; i < n; i++) {
        sb.append(s);
    }
    return sb.toString();
}

basé sur la réponse de fortran , ceci est une version récursive qui utilise un StringBuilder:

public static void repeat(StringBuilder stringBuilder, String s, int times) {
    if (times > 0) {
        repeat(stringBuilder.append(s), s, times - 1);
    }
}

public static String repeat(String s, int times) {
    StringBuilder stringBuilder = new StringBuilder(s.length() * times);
    repeat(stringBuilder, s, times);
    return stringBuilder.toString();
}

utiliser Dollar est aussi simple que de taper:

@Test
public void repeatString() {
    String string = "abc";
    assertThat($(string).repeat(3).toString(), is("abcabcabc"));
}

PS: la répétition fonctionne également pour le tableau, la liste, le jeu, etc.

Je voulais une fonction pour créer une liste de points d'interrogation séparés par des virgules à des fins JDBC, et j'ai trouvé ce message. J'ai donc décidé de prendre deux variantes et de voir laquelle fonctionnait mieux. Après 1 million d'itérations, le StringBuilder, une variété de jardin, a pris 2 secondes (fun1), et la version cryptique supposée plus optimale (fun2) a pris 30 secondes. Quel est l'intérêt d'être à nouveau cryptique?

private static String fun1(int size) {
    StringBuilder sb = new StringBuilder(size * 2);
    for (int i = 0; i < size; i++) {
        sb.append(",?");
    }
    return sb.substring(1);
}

private static String fun2(int size) {
    return new String(new char[size]).replaceAll("\0", ",?").substring(1);
}

Solution POO

Presque toutes les réponses proposent une fonction statique comme solution, mais en pensant orienté objet (à des fins de réutilisabilité et de clarté), j'ai trouvé une solution via la délégation via l'interface CharSequence (qui ouvre également l'utilisabilité sur les classes CharSequence mutables).

La classe suivante peut être utilisée avec ou sans Separator-String / CharSequence et chaque appel à "toString ()" crée la chaîne répétée finale. Les entrées / séparateurs ne sont pas seulement limités à String-Class, mais peuvent être toutes les classes qui implémentent CharSequence (par exemple StringBuilder, StringBuffer, etc.)!

Code source:

/**
 * Helper-Class for Repeating Strings and other CharSequence-Implementations
 * @author Maciej Schuttkowski
 */
public class RepeatingCharSequence implements CharSequence {
    final int count;
    CharSequence internalCharSeq = "";
    CharSequence separator = "";
    /**
     * CONSTRUCTOR - RepeatingCharSequence
     * @param input CharSequence to repeat
     * @param count Repeat-Count
     */
    public RepeatingCharSequence(CharSequence input, int count) {
        if(count < 0)
            throw new IllegalArgumentException("Can not repeat String \""+input+"\" less than 0 times! count="+count);
        if(count > 0)
            internalCharSeq = input;
        this.count = count;
    }
    /**
     * CONSTRUCTOR - Strings.RepeatingCharSequence
     * @param input CharSequence to repeat
     * @param count Repeat-Count
     * @param separator Separator-Sequence to use
     */
    public RepeatingCharSequence(CharSequence input, int count, CharSequence separator) {
        this(input, count);
        this.separator = separator;
    }

    @Override
    public CharSequence subSequence(int start, int end) {
        checkBounds(start);
        checkBounds(end);
        int subLen = end - start;
        if (subLen < 0) {
            throw new IndexOutOfBoundsException("Illegal subSequence-Length: "+subLen);
        }
        return (start == 0 && end == length()) ? this
                    : toString().substring(start, subLen);
    }
    @Override
    public int length() {
        //We return the total length of our CharSequences with the separator 1 time less than amount of repeats:
        return count < 1 ? 0
                : ( (internalCharSeq.length()*count) + (separator.length()*(count-1)));
    }
    @Override
    public char charAt(int index) {
        final int internalIndex = internalIndex(index);
        //Delegate to Separator-CharSequence or Input-CharSequence depending on internal index:
        if(internalIndex > internalCharSeq.length()-1) {
            return separator.charAt(internalIndex-internalCharSeq.length());
        }
        return internalCharSeq.charAt(internalIndex);
    }
    @Override
    public String toString() {
        return count < 1 ? ""
                : new StringBuilder(this).toString();
    }

    private void checkBounds(int index) {
        if(index < 0 || index >= length())
            throw new IndexOutOfBoundsException("Index out of Bounds: "+index);
    }
    private int internalIndex(int index) {
        // We need to add 1 Separator-Length to total length before dividing,
        // as we subtracted one Separator-Length in "length()"
        return index % ((length()+separator.length())/count);
    }
}

Exemple d'utilisation:

public static void main(String[] args) {
    //String input = "12345";
    //StringBuffer input = new StringBuffer("12345");
    StringBuilder input = new StringBuilder("123");
    //String separator = "<=>";
    StringBuilder separator = new StringBuilder("<=");//.append('>');
    int repeatCount = 2;

    CharSequence repSeq = new RepeatingCharSequence(input, repeatCount, separator);
    String repStr = repSeq.toString();

    System.out.println("Repeat="+repeatCount+"\tSeparator="+separator+"\tInput="+input+"\tLength="+input.length());
    System.out.println("CharSeq:\tLength="+repSeq.length()+"\tVal="+repSeq);
    System.out.println("String :\tLength="+repStr.length()+"\tVal="+repStr);

    //Here comes the Magic with a StringBuilder as Input, as you can append to the String-Builder
    //and at the same Time your Repeating-Sequence's toString()-Method returns the updated String :)
    input.append("ff");
    System.out.println(repSeq);
    //Same can be done with the Separator:
    separator.append("===").append('>');
    System.out.println(repSeq);
}

Exemple de sortie:

Repeat=2    Separator=<=    Input=123   Length=3
CharSeq:    Length=8    Val=123<=123
String :    Length=8    Val=123<=123
123ff<=123ff
123ff<====>123ff

en utilisant uniquement des classes JRE ( System.arraycopy ) et en essayant de minimiser le nombre d'objets temporaires, vous pouvez écrire quelque chose comme:

public static String repeat(String toRepeat, int times) {
    if (toRepeat == null) {
        toRepeat = "";
    }

    if (times < 0) {
        times = 0;
    }

    final int length = toRepeat.length();
    final int total = length * times;
    final char[] src = toRepeat.toCharArray();
    char[] dst = new char[total];

    for (int i = 0; i < total; i += length) {
        System.arraycopy(src, 0, dst, i, length);
    }

    return String.copyValueOf(dst);
}

ÉDITER

et sans boucles, vous pouvez essayer avec:

public static String repeat2(String toRepeat, int times) {
    if (toRepeat == null) {
        toRepeat = "";
    }

    if (times < 0) {
        times = 0;
    }

    String[] copies = new String[times];
    Arrays.fill(copies, toRepeat);
    return Arrays.toString(copies).
              replace("[", "").
              replace("]", "").
              replaceAll(", ", "");
}

EDIT 2

l'utilisation des collections est encore plus courte:

public static String repeat3(String toRepeat, int times) {
    return Collections.nCopies(times, toRepeat).
           toString().
           replace("[", "").
           replace("]", "").
           replaceAll(", ", "");
}

cependant j'aime toujours la première version.

Pas le plus court, mais (je pense) le moyen le plus rapide est d'utiliser le StringBuilder:

 /**
   * Repeat a String as many times you need.
   *
   * @param i - Number of Repeating the String.
   * @param s - The String wich you want repeated.
   * @return The string n - times.
   */
  public static String repeate(int i, String s) {
    StringBuilder sb = new StringBuilder();
    for (int j = 0; j < i; j++)
      sb.append(s);
    return sb.toString();
  }

Si la vitesse est votre préoccupation, vous devez utiliser le moins de copie de mémoire possible. Il est donc nécessaire de travailler avec des tableaux de caractères.

public static String repeatString(String what, int howmany) {
    char[] pattern = what.toCharArray();
    char[] res = new char[howmany * pattern.length];
    int length = pattern.length;
    for (int i = 0; i < howmany; i++)
        System.arraycopy(pattern, 0, res, i * length, length);
    return new String(res);
}

Pour tester la vitesse, une méthode optimale similaire utilisant StirngBuilder est comme ceci:

public static String repeatStringSB(String what, int howmany) {
    StringBuilder out = new StringBuilder(what.length() * howmany);
    for (int i = 0; i < howmany; i++)
        out.append(what);
    return out.toString();
}

et le code pour le tester:

public static void main(String... args) {
    String res;
    long time;

    for (int j = 0; j < 1000; j++) {
        res = repeatString("123", 100000);
        res = repeatStringSB("123", 100000);
    }

    time = System.nanoTime();
    res = repeatString("123", 1000000);
    time = System.nanoTime() - time;
    System.out.println("elapsed repeatString: " + time);

    time = System.nanoTime();
    res = repeatStringSB("123", 1000000);
    time = System.nanoTime() - time;
    System.out.println("elapsed repeatStringSB: " + time);

}

Et voici les résultats de l'exécution de mon système:

elapsed repeatString: 6006571
elapsed repeatStringSB: 9064937

Notez que le test de boucle consiste à lancer JIT et à obtenir des résultats optimaux.

pour des raisons de lisibilité et de portabilité:

public String repeat(String str, int count){
    if(count <= 0) {return "";}
    return new String(new char[count]).replace("\0", str);
}

Si vous êtes préoccupé par les performances, utilisez simplement un StringBuilder dans la boucle et faites un .toString () à la sortie de la boucle. Heck, écrivez votre propre classe Util et réutilisez-la. 5 lignes de code max.

J'apprécie vraiment cette question. Il y a beaucoup de connaissances et de styles. Je ne peux donc pas le quitter sans montrer mon rock and roll;)

{
    String string = repeat("1234567890", 4);
    System.out.println(string);
    System.out.println("=======");
    repeatWithoutCopySample(string, 100000);
    System.out.println(string);// This take time, try it without printing
    System.out.println(string.length());
}

/**
 * The core of the task.
 */
@SuppressWarnings("AssignmentToMethodParameter")
public static char[] repeat(char[] sample, int times) {
    char[] r = new char[sample.length * times];
    while (--times > -1) {
        System.arraycopy(sample, 0, r, times * sample.length, sample.length);
    }
    return r;
}

/**
 * Java classic style.
 */
public static String repeat(String sample, int times) {
    return new String(repeat(sample.toCharArray(), times));
}

/**
 * Java extreme memory style.
 */
@SuppressWarnings("UseSpecificCatch")
public static void repeatWithoutCopySample(String sample, int times) {
    try {
        Field valueStringField = String.class.getDeclaredField("value");
        valueStringField.setAccessible(true);
        valueStringField.set(sample, repeat((char[]) valueStringField.get(sample), times));
    } catch (Exception ex) {
        throw new RuntimeException(ex);
    }
}

Aimes-tu?

public static String repeat(String str, int times) {
    int length = str.length();
    int size = length * times;
    char[] c = new char[size];
    for (int i = 0; i < size; i++) {
        c[i] = str.charAt(i % length);
    }
    return new String(c);
}

Boucle simple

public static String repeat(String string, int times) {
    StringBuilder out = new StringBuilder();
    while (times-- > 0) {
        out.append(string);
    }
    return out.toString();
}

Essayez ceci:

public static char[] myABCs = {'a', 'b', 'c'};
public static int numInput;
static Scanner in = new Scanner(System.in);

public static void main(String[] args) {
    System.out.print("Enter Number of Times to repeat: ");
    numInput = in.nextInt();
    repeatArray(numInput);
}

public static int repeatArray(int y) {
    for (int a = 0; a < y; a++) {
        for (int b = 0; b < myABCs.length; b++) {
            System.out.print(myABCs[b]);                
        }
        System.out.print(" ");
    }
    return y;
}

En utilisant la récursivité, vous pouvez faire ce qui suit (en utilisant des opérateurs ternaires, une ligne max):

public static final String repeat(String string, long number) {
    return number == 1 ? string : (number % 2 == 0 ? repeat(string + string, number / 2) : string + repeat(string + string, (number - 1) / 2));
}

Je sais, c'est moche et probablement pas efficace, mais c'est une seule ligne!

une solution simple en ligne:
nécessite Java 8

Collections.nCopies( 3, "abc" ).stream().collect( Collectors.joining() );

Malgré votre désir de ne pas utiliser de boucles, je pense que vous devriez utiliser une boucle.

String repeatString(String s, int repetitions)
{
    if(repetitions < 0) throw SomeException();

    else if(s == null) return null;

    StringBuilder stringBuilder = new StringBuilder(s.length() * repetitions);

    for(int i = 0; i < repetitions; i++)
        stringBuilder.append(s);

    return stringBuilder.toString();
}

Vos raisons de ne pas utiliser de boucle for ne sont pas bonnes. En réponse à vos critiques:

1. Quelle que soit la solution que vous utiliserez, elle sera certainement plus longue que cela. L'utilisation d'une fonction pré-construite ne fait que la placer sous plus de couvertures.
2. Quelqu'un qui lit votre code devra comprendre ce que vous faites dans cette boucle sans boucle. Étant donné qu'une boucle for est la façon idiomatique de le faire, il serait beaucoup plus facile de déterminer si vous l'avez fait avec une boucle for.
3. Oui quelqu'un pourrait ajouter quelque chose d' intelligent, mais en évitant une boucle que vous êtes en train de faire quelque chose d' intelligent . C'est comme se tirer une balle dans le pied intentionnellement pour éviter de se tirer dans le pied par accident.
4. Les erreurs ponctuelles sont également incroyablement faciles à détecter avec un seul test. Étant donné que vous devriez tester votre code, une erreur hors-ligne devrait être facile à corriger et à détecter. Et cela vaut la peine de le noter: le code ci-dessus ne contient pas d'erreur off-by-one. Car les boucles sont tout aussi faciles à réaliser.
5. Ne réutilisez donc pas les variables. Ce n'est pas la faute de la boucle for.
6. Encore une fois, il en va de même de la solution que vous utilisez. Et comme je l'ai noté précédemment; un chasseur de bogues s'attendra probablement à ce que vous le fassiez avec une boucle for, il aura donc plus de facilité à le trouver si vous utilisez une boucle for.

Si vous ne connaissez que la longueur de la chaîne de sortie (et qu'elle peut ne pas être divisible par la longueur de la chaîne d'entrée), utilisez cette méthode:

static String repeat(String s, int length) {
    return s.length() >= length ? s.substring(0, length) : repeat(s + s, length);
}

Démo d'utilisation:

for (int i = 0; i < 50; i++)
    System.out.println(repeat("_/‾\\", i));

Ne pas utiliser avec vide set length> 0, car il est impossible d'obtenir le résultat souhaité dans ce cas.

voici le dernier Stringutils.java StringUtils.java

    public static String repeat(String str, int repeat) {
    // Performance tuned for 2.0 (JDK1.4)

    if (str == null) {
        return null;
    }
    if (repeat <= 0) {
        return EMPTY;
    }
    int inputLength = str.length();
    if (repeat == 1 || inputLength == 0) {
        return str;
    }
    if (inputLength == 1 && repeat <= PAD_LIMIT) {
        return repeat(str.charAt(0), repeat);
    }

    int outputLength = inputLength * repeat;
    switch (inputLength) {
        case 1 :
            return repeat(str.charAt(0), repeat);
        case 2 :
            char ch0 = str.charAt(0);
            char ch1 = str.charAt(1);
            char[] output2 = new char[outputLength];
            for (int i = repeat * 2 - 2; i >= 0; i--, i--) {
                output2[i] = ch0;
                output2[i + 1] = ch1;
            }
            return new String(output2);
        default :
            StringBuilder buf = new StringBuilder(outputLength);
            for (int i = 0; i < repeat; i++) {
                buf.append(str);
            }
            return buf.toString();
    }
    }

il n'a même pas besoin d'être aussi gros, peut être transformé en ceci, et peut être copié et collé dans une classe utilitaire dans votre projet.

    public static String repeat(String str, int num) {
    int len = num * str.length();
    StringBuilder sb = new StringBuilder(len);
    for (int i = 0; i < times; i++) {
        sb.append(str);
    }
    return sb.toString();
    }

Donc e5, je pense que la meilleure façon de faire serait d'utiliser simplement le code mentionné ci-dessus, ou l'une des réponses ici. mais lang communes est tout simplement trop grand si c'est un petit projet

J'ai créé une méthode récursive qui fait la même chose que vous voulez .. n'hésitez pas à utiliser cela ...

public String repeat(String str, int count) {
    return count > 0 ?  repeat(str, count -1) + str: "";
}

j'ai la même réponse sur Puis-je multiplier les chaînes en java pour répéter les séquences?

public static String rep(int a,String k)

       {
           if(a<=0)
                return "";
           else 
           {a--;
               return k+rep(a,k);
       }

Vous pouvez utiliser cette méthode récursive pour votre objectif souhaité.