Façon Simple de répéter une chaîne de caractères en java

je suis à la recherche d'une méthode ou d'un opérateur commons simple qui me permet de répéter une chaîne de caractères n fois. Je sais que je pourrais écrire ceci en utilisant une boucle pour, mais je souhaite éviter pour les boucles 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");

lié à:

répéter chaîne javascript créer NSString en répétant une autre chaîne a nombre de fois

Édité

j'essaie d'éviter pour les boucles quand elles ne sont pas complètement nécessaires parce que:

  1. Ils ajoutent au nombre de lignes de code, même si elles sont planquées dans une autre fonction.

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

  3. les programmeurs aiment mettre des choses intelligentes pour les boucles, même si je l'écris pour "ne faire que ce qu'il est prévu de faire", cela n'empêche pas quelqu'un de venir et d'ajouter une "correction"intelligente supplémentaire.

  4. ils sont très souvent faciles à se tromper. Pour les boucles impliquant des index ont tendance à générer par un bugs.

  5. pour les boucles réutilisent souvent les mêmes variables, ce qui augmente les chances de trouver des bogues vraiment difficiles à cerner.

  6. pour les boucles augmenter le nombre d'endroits qu'un chasseur de bugs doit regarder.

434
demandé sur Community 2009-08-05 23:14:38

29 réponses

De Java 11, il y a une méthode String::repeat qui fait exactement ce que tu as demandé:

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

Sa 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
 */ 
48
répondu Nicolai 2018-09-29 07:57:19

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

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

n est le nombre de fois que vous voulez répéter la chaîne et s est la chaîne à répéter.

pas besoin d'importations ou de bibliothèques.

755
répondu user102008 2015-11-20 17:55:02

Commons Lang StringUtils.répéter ()

Utilisation:

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

repeated.equals("abcabcabc");
270
répondu ChssPly76 2013-08-26 07:34:02

si vous utilisez Java <= 7 , c'est aussi simple que cela peut l'être:

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

Dans Java 8 et au-dessus il y a une façon très simple:

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

Java 11 a ajouté une nouvelle méthode repeat​(int count) spécifiquement pour cela ( link )

int n = 3;
"abc".repeat(n);
192
répondu Caner 2018-09-28 15:30:05

Java 8's String.join fournit une façon ordonnée de le faire en conjonction avec Collections.nCopies :

// say hello 100 times
System.out.println(String.join("", Collections.nCopies(100, "hello")));
121
répondu Boann 2015-05-21 17:53:24

Voici une façon de le faire en utilisant seulement les fonctions de chaîne standard et pas de boucles explicites:

// create a string made up of  n  copies of  s
repeated = String.format(String.format("%%%ds", n), " ").replace(" ",s);
97
répondu I. J. Kennedy 2015-10-30 17:34:10

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

Strings.repeat("-", 60);
78
répondu Jack 2012-05-20 23:33:29

avec , 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());
}
47
répondu Alexis C. 2015-02-09 17:10:01

vous voulez é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 laid et inefficace, mais il n'a pas de boucles :-p)

tu veux que ce soit plus simple et plus joli? utilisation 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 rapide et sale benchmark pour les 4 alternatives principales, 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 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 faut 2 arguments, le premier est le nombre d'itérations (chaque fonction s'exécute avec des temps de répétition arg à partir de 1..n) et la seconde est la chaîne à répéter.

jusqu'à présent, une inspection rapide des temps de fonctionnement avec différentes entrées laisse la classer quelque chose comme ceci (de mieux à pire):

  1. iterative StringBuilder ajoute (1x).
  2. Récursive concaténation log2 invocations (~3x).
  3. Récursive concaténation linéaire invocations (~30x).
  4. Itératif concaténation linéaire (~45x).

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

Avoir du plaisir(fonctionnelle xD).

32
répondu fortran 2009-08-06 12:20:51

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();
}
21
répondu Pyrolistical 2014-11-14 16:10:29

basé sur fortran réponse , c'est un recusive version 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();
}
9
répondu dfa 2017-05-23 10:31:38

utilisant Dollar est simple comme Dactylographie:

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

PS: répéter fonctionne aussi pour les array, List, Set, etc

7
répondu dfa 2010-02-01 16:01:28

je voulais une fonction pour créer une liste de points d'interrogation délimitée par des virgules pour les besoins de la JDBC, et j'ai trouvé ce message. J'ai donc décidé de prendre deux variantes et de voir laquelle fonctionnait le mieux. Après 1 million d'itérations, le constructeur de cordes garden-variety a pris 2 secondes (fun1), et la version cryptique supposée plus optimale (fun2) a pris 30 secondes. A quoi ça sert d'être énigmatique, déjà?

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(""151900920"", ",?").substring(1);
}
7
répondu Bob 2012-12-06 14:42:04

OOP Solution

presque toutes les réponses proposent une fonction statique comme solution, mais la pensée orientée objet (pour la réutilisabilité-buts et la clarté) j'ai proposé une Solution via la délégation par L'intermédiaire de CharSequence-Interface (qui ouvre également la usability sur Mutable CharSequence-Classes).

la classe suivante peut être utilisée avec ou sans Séparator-String / CharSequence et chaque appel à" toString () " construit le final répété Chaîne. 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)!

Source-Code:

/**
 * 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);
    }
}
"151930920 D'Utilisation"-Exemple:
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-Sortie:

Repeat=2    Separator=<=    Input=123   Length=3
CharSeq:    Length=8    Val=123<=123
String :    Length=8    Val=123<=123
123ff<=123ff
123ff<====>123ff
6
répondu Maciej Schuttkowski 2015-08-06 16:48:21

utilisant uniquement les classes JRE (système ).arraycopy ) et essayer de minimiser le nombre d'objets temp 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);
}

MODIFIER

et sans boucles, vous pouvez essayer:

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

utilisant Collections est encore plus court:

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

cependant j'ai toujours aimé la première version.

5
répondu dfa 2010-02-01 16:20:20

si la vitesse est votre préoccupation, alors vous devez utiliser autant moins de copie mémoire que possible. Ainsi, il est 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 le résultat de la course de mon système:

elapsed repeatString: 6006571
elapsed repeatStringSB: 9064937

notez que le test pour boucle est de donner un coup de pied dans JIT et avoir des résultats optimaux.

4
répondu Panayotis 2017-05-18 23:28:55

pas le plus court, mais (je pense) 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();
  }
3
répondu Simo 2017-10-12 12:58:47

si vous êtes inquiet au sujet de la performance, il suffit d'utiliser un StringBuilder à l'intérieur de la boucle et faire un .toString() à la sortie de la Boucle. Heck, écrivez votre propre classe Util et réutilisez-la. 5 lignes de code max.

2
répondu WolfmanDragon 2009-08-05 19:21:15

j'apprécie vraiment cette question. Il y a beaucoup de connaissances et de styles. Donc je ne peux pas la laisser 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);
    }
}

ça te plaît?

2
répondu Daniel De León 2013-04-03 00:56:20

Simple boucle

public static String repeat(String string, int times) {
    StringBuilder out = new StringBuilder();
    while (times-- > 0) {
        out.append(string);
    }
    return out.toString();
}
2
répondu Codler 2013-06-25 11:49:26

en utilisant la récursion, vous pouvez faire ce qui suit (en utilisant les 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 laid et probablement pas efficace, mais c'est une ligne!

2
répondu HyperNeutrino 2015-06-08 00:31:45

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(""151900920"", str);
}
2
répondu Martin Zeitler 2016-09-21 08:40:14

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 un For loop ne sont pas bonnes. En réponse à vos critiques:

  1. quelle que soit la solution que vous utilisez, elle sera certainement plus longue que celle-ci. En utilisant une fonction pré-construite seulement le tucks Sous plus de couvertures.
  2. Quelqu'un lisant votre code devra comprendre ce que vous faites là non-pour-boucle. Étant donné qu'une boucle pour est la façon idiomatique de faire cela, il serait beaucoup plus facile de comprendre si vous l'avez fait avec une boucle pour.
  3. Oui quelqu'un pourrait ajouter quelque chose d'intelligent, mais en évitant un pour boucle vous sont faire quelque chose d'intelligent . C'est comme se tirer dans le pied intentionnellement pour éviter de se tirer dans le pied par accident.
  4. les erreurs "Off-by-one" sont aussi déconcertantes facile à attraper avec un seul test. Étant donné que vous devriez tester votre code, une erreur "off-by-one" devrait être facile à corriger et à saisir. Et il est intéressant de noter: le code ci-dessus ne contient pas de une-par-une erreur. Pour les boucles sont également faciles à obtenir droite.
  5. donc ne réutilisez pas les variables. Ce n'est pas la pour-de la boucle de défaut.
  6. encore une fois, quelle que soit la solution que vous utilisez. Et comme je l'ai déjà noté, un chasseur de bugs s'attendra probablement à ce que vous le fassiez avec un boucle, donc ils auront un temps plus facile de le trouver si vous utilisez un pour boucle.
1
répondu Imagist 2009-08-05 22:21:46
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);
}
1
répondu falcon 2013-05-31 13:05:02

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;
}
1
répondu 2013-11-13 14:25:22

voici les derniers 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 grande, peut être fait dans ce, 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 le faire serait d'utiliser simplement le code mentionné ci-dessus,ou l'un quelconque des réponses ici. mais commons lang est juste trop grand si c'est un petit projet

0
répondu alexmherrmann 2011-08-11 04:58:24

j'ai créé une méthode récursive qui font la même chose que vous souhaitez.. n'hésitez pas à utiliser ce...

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 des séquences?

0
répondu niczm25 2017-05-23 12:10:47
repeated = str + str + str;

parfois simple est préférable. Tous ceux qui lisent le code peuvent voir ce qui se passe.

et le compilateur va faire les trucs de fantaisie avec StringBuilder dans les coulisses pour vous.

-3
répondu Will 2014-10-09 13:23:49

Voici une façon simple de répéter une étoile, un certain nombre de fois (jusqu'à un certain maximale connue):

String stars = "*****".substring(0, n);
-5
répondu Nautilus 2016-01-21 12:13:57