Einfache Weise zu wiederholen, einen String in java

Hier ist die kürzeste version (Java 1.5+ erforderlich):

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

Wo n ist die Anzahl der Zeiten, die Sie wiederholen möchten, die string-und die s ist die Zeichenfolge zu wiederholen.

Keine Einfuhr-oder Bibliotheken, die benötigt werden.

InformationsquelleAutor user102008

Wenn Sie Java <= 7, das ist so einfach, wie es geht:

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

In Java 8 und oben gibt es eine einfache Möglichkeit:

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

Java 11 wurde eine neue repeat​(int count) Methode, die speziell für diese(link)

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

InformationsquelleAutor Caner

Hier ist ein Weg, es zu tun, nur mit standard-String-Funktionen und keine expliziten Schleifen:

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

InformationsquelleAutor I. J. Kennedy

Mit java-8, Sie können auch Stream.generate.

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

und Sie können wickeln Sie es in ein einfaches Dienstprogramm-Methode, wenn nötig:

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

InformationsquelleAutor Alexis C.

Diese enthält weniger Zeichen, als Sie Ihre Frage

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

InformationsquelleAutor Pyrolistical

mit Dollar ist einfach, wie Sie:

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

PS: wiederholen funktioniert auch für array, List, Set, etc

InformationsquelleAutor dfa

OOP-Lösung

Fast jede Antwort schlägt vor, eine statische Funktion als Lösung, sondern denken, Objekt-Orientierte (für die Wiederverwendbarkeit-Zwecke und Klarheit) kam ich auf eine Lösung via Delegation durch das CharSequence-Interface (das öffnet auch die Benutzerfreundlichkeit auf veränderliche CharSequence-Klassen).

Die folgende Klasse verwendet werden können, entweder mit oder ohne Separator-String/CharSequence, und jeder Aufruf von "toString()" baut die endgültige wiederholte Zeichenfolge.
Die Eingabe - /Trennzeichen sind nicht nur beschränkt auf die String-Klasse, sondern kann jede Klasse, die implementiert CharSequence (z.B. 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);
    }
}

- Nutzung-Beispiel:

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

Beispiel-Ausgabe:

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

InformationsquelleAutor Maciej Schuttkowski

Wenn die Geschwindigkeit ist Ihr Anliegen, dann sollten Sie verwenden weniger Speicher kopiert wie möglich. Es ist daher erforderlich, um die Arbeit mit arrays von chars.

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

Testen Geschwindigkeit, eine ähnlich optimale Methode mit StirngBuilder ist wie folgt:

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

und den code um es zu testen:

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

}

Und hier die Ergebnisse von meinem system:

elapsed repeatString: 6006571
elapsed repeatStringSB: 9064937

Beachten Sie, dass der test für die Schleife ist kick-in JIT und haben optimale Ergebnisse zu erzielen.

InformationsquelleAutor Panayotis

Nicht die kürzeste, aber (glaube ich) der Schnellste Weg ist die Verwendung der Klasse 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();
  }

InformationsquelleAutor Simon

Genieße ich wirklich diese Frage. Es gibt eine Menge von wissen und Stilen. So kann ich nicht verlassen, ohne meine 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);
    }
}

Wie findet Ihr es?

InformationsquelleAutor Daniel De León

Probieren Sie es aus:

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

InformationsquelleAutor

Trotz Ihres Wunsches nicht verwenden Schleifen, die ich denke, Sie sollten eine Schleife verwenden.

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

Ihre Gründe für die nicht-Verwendung einer for-Schleife nicht gut sind. In Reaktion auf Ihre Kritik:

1. Welche Lösung auch immer Sie verwenden, werden sicherlich mehr als diese. Mit einem pre-built Funktion nur versteckt Sie es unter mehr deckt.
2. Jemand Lesen Sie Ihre code haben, um herauszufinden, was Sie tun, nicht-for-Schleife. Da eine for-Schleife ist die idiomatischen Weg, dies zu tun, wäre es viel einfacher, um herauszufinden, wenn Sie habe es mit einer for-Schleife.
3. Ja jemand etwas hinzufügen klug, aber durch die Vermeidung einer for-Schleife Sie sind etwas zu tun clever. Das ist wie das Schießen selbst in den Fuß absichtlich zu vermeiden, Schießen selbst in den Fuß durch Unfall.
4. Off-by-one-Fehler sind auch Geist-betäubend leicht zu fangen, mit einem einzigen test. Da sollten Sie testen Ihren code, ein off-by-one-Fehler sollte leicht zu reparieren und zu fangen. Und es ist erwähnenswert: der code oben nicht enthalten ist eine off-by-one-Fehler. For-Schleifen sind ebenso leicht zu bekommen Recht.
5. Also nicht wiederverwenden von Variablen. Das ist nicht die for-Schleife ist Schuld.
6. Wieder so tut, was auch immer Lösung, die Sie verwenden. Und wie ich bereits zuvor; ein bug hunter wird wahrscheinlich erwartet, dass du dies mit einer for-Schleife, so werden Sie es leichter haben, es zu finden, wenn Sie eine for-Schleife verwenden.

InformationsquelleAutor Imagist

hier ist die neueste 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();
    }
    }

es muss nicht einmal so groß wird, gemacht werden können in diesem, und können kopiert und eingefügt werden
in einer utility-Klasse in Ihrem Projekt.

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

Also e5, ich denke, der beste Weg, dies zu tun wäre, nutzen Sie einfach den oben genannten code,oder eine der Antworten hier. aber commons lang ist einfach zu groß, wenn es ein kleines Projekt

InformationsquelleAutor alexmherrmann

repeated = str + str + str;

Manchmal einfach ist am besten. Alle Lesen den code sehen können, was passiert.

Und der compiler die fancy stuff mit StringBuilder hinter den kulissen für Sie.

InformationsquelleAutor Will