Moyen Simple de répéter une Chaîne de caractères en java

Ici est la version la plus courte (Java 1.5+ requis):

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

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

Pas les importations ou les bibliothèques nécessaires.

Si vous utilisez Java <= 7, c'est aussi simple que cela:

//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 un moyen simple:

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

Java 11 ajouté une nouvelle repeat​(int count) méthode spécifiquement pour cette(lien)

int n = 3;
"abc".repeat(n);

Ici un moyen de le faire en utilisant uniquement des fonctions de chaînes de caractères et non explicite boucles:

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

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 un utilitaire simple méthode, si nécessaire:

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

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

à l'aide de Dollar est très simple:

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

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

OOP Solution

Presque chaque réponse propose une fonction statique comme une solution, mais la pensée de l'Orienté Objet (pour la réutilisabilité et la clarté), je suis venu avec une Solution via la Délégation par le CharSequence-Interface (qui ouvre également la facilité d'utilisation sur mutable CharSequence-Classes).

La Classe suivante peut être utilisée avec ou sans Séparateur de Chaîne/CharSequence et chaque appel à "toString ()", développe la finale répétées de la Chaîne.
L'Entrée/Séparateur ne sont pas seulement limités à la Chaîne de Classe, mais il peut être chaque Classe qui implémente CharSequence (par exemple StringBuilder, StringBuffer, etc)!

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

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

Si la vitesse est votre préoccupation, alors vous devriez utiliser le moins de mémoire de la copie 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);
}

Afin de tester la vitesse, une semblable méthode optimale à l'aide de 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 mon système:

elapsed repeatString: 6006571
elapsed repeatStringSB: 9064937

Noter que le test de la boucle coup de pied dans JIT et avoir des résultats optimaux.

Pas le plus court, mais (je pense) le moyen le plus rapide est d'utiliser la classe 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();
}

J'ai vraiment plaisir à 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);
}
}

Vous aimez?

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

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 pour ne pas utiliser une boucle for ne sont pas bons. En réponse à vos critiques:

1. Quelque soit la solution que vous utilisez sera presque certainement être plus que cela. À l'aide d'un pré-construit pour seule fonction la coince sous couvre plus.
2. Quelqu'un de lire votre code devra comprendre ce que vous faites en ce que le non-pour-boucle. Étant donné que d'une boucle for est la idiomatiques façon de le faire, il serait beaucoup plus facile à comprendre si vous l'avez fait avec une boucle for.
3. Oui quelqu'un pourrait ajouter quelque chose d'intelligent, mais en évitant une boucle for vous sont faire quelque chose d'intelligent. C'est comme se tirer une balle dans le pied intentionnellement pour éviter de se tirer une balle dans le pied par accident.
4. Tout-en-un, les erreurs sont également l'esprit numbingly facile à attraper avec un seul test. Étant donné que vous devez tester votre code, un tout-en-un message d'erreur devrait être facile à fixer et à attraper. Et il est intéressant de noter: le code ci-dessus ne contient pas de une-par-une erreur. Pour les boucles sont aussi faciles à obtenir le droit.
5. Afin de ne pas réutiliser les variables. Ce n'est pas la pour-de la boucle de défaut.
6. De nouveau, donc quelle que soit la solution que vous utilisez. Et comme je l'ai mentionné avant; un bug hunter va probablement être attend de vous à ce faire avec une boucle for, donc ils ont un temps plus facile de le trouver si vous utilisez une boucle for.

voici la dernière 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 tout simplement trop gros si c'est un petit projet

repeated = str + str + str;

Parfois simple est le meilleur. Tout le monde de lire le code peut voir ce qui se passe.

Et le compilateur ne la fantaisie avec StringBuilder derrière les coulisses pour vous.