Einfache Möglichkeit, einen String in java zu wiederholen

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

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

Wobei n die Anzahl der Wiederholungen der Zeichenfolge ist und s die zu wiederholende Zeichenfolge ist.

Keine Importe oder Bibliotheken erforderlich.

Commons Lang StringUtils.repeat ()

Verwendungszweck:

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

repeated.equals("abcabcabc");

Wenn Sie Java <= 7 verwenden, ist dies so einfach wie es nur 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 höher gibt es einen einfachen Weg:

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

Java 11 hat eine neue repeat​(int count) Methode speziell für diese hinzugefügt ( link )

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

Java 8s String.join bietet eine übersichtliche Möglichkeit, dies in Verbindung mit Collections.nCopies zu tun:

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

Hier ist eine Möglichkeit, dies nur mit Standard-String-Funktionen und ohne explizite Schleifen zu tun:

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

Wenn Sie wie ich sind und Google Guava und nicht Apache Commons verwenden möchten. Sie können die repeat -Methode in der Guava Strings-Klasse verwenden.

Strings.repeat("-", 60);

Mit Java-8 können Sie auch Stream.generate verwenden.

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

und Sie können es bei Bedarf in eine einfache Dienstprogrammmethode einbinden:

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

Sie möchten also Schleifen vermeiden?

Hier hast du es:

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

(Natürlich weiß ich, dass dies hässlich und ineffizient ist, aber es gibt keine Schleifen :-p)

Sie wollen es einfacher und schöner? benutze jython:

s * 3

Edit: lass es uns ein wenig optimieren :-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: Ich habe einen schnellen und schmutzigen Benchmark für die 4 Hauptalternativen durchgeführt, aber ich habe keine Zeit, ihn mehrmals auszuführen, um die Mittel zu ermitteln und die Zeiten für mehrere Eingaben zu zeichnen ... Also hier ist der Code, wenn jemand es versuchen möchte:

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

Es werden 2 Argumente benötigt, das erste ist die Anzahl der Iterationen (jede Funktion wird mit Wiederholungszeiten arg von 1..n ausgeführt) und das zweite ist die zu wiederholende Zeichenfolge.

Bisher ergibt eine schnelle Überprüfung der laufenden Zeiten mit unterschiedlichen Eingaben eine Rangfolge wie die folgende (besser zu schlechter):

1. Iterativer StringBuilder-Anhang (1x).
2. Rekursive Verkettungslog2-Aufrufe (~ 3x).
3. Rekursive Verkettung linearer Aufrufe (~ 30x).
4. Iterative Verkettung linear (~ 45x).

Ich hätte nie gedacht, dass die rekursive Funktion schneller ist als die for -Schleife: -o

Viel Spaß (ctional xD).

Dies enthält weniger Zeichen als 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();
}

basierend auf fortran answer ist dies eine rekursive Version, die einen StringBuilder verwendet:

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

Ich wollte eine Funktion zum Erstellen einer durch Kommas getrennten Liste von Fragezeichen für JDBC-Zwecke und habe diesen Beitrag gefunden. Also habe ich mich für zwei Varianten entschieden und herausgefunden, welche besser abschneiden. Nach 1 Million Iterationen dauerte die Gartensorte StringBuilder 2 Sekunden (fun1) und die kryptisch angeblich optimalere Version (fun2) 30 Sekunden. Was nützt es, wieder kryptisch zu sein?

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

OOP-Lösung

Nahezu jede Antwort schlägt eine statische Funktion als Lösung vor, aber ich habe objektorientiert gedacht (aus Gründen der Wiederverwendbarkeit und Klarheit) und über die CharSequence-Schnittstelle eine Lösung per Delegation gefunden (die auch die Verwendbarkeit für veränderbare CharSequence-Klassen eröffnet).

Die folgende Klasse kann entweder mit oder ohne Separator-String/CharSequence verwendet werden, und jeder Aufruf von "toString ()" erstellt den endgültigen wiederholten String. Der Input/Separator ist nicht nur auf String-Class beschränkt, sondern kann jede Klasse sein, die CharSequence implementiert (z. B. StringBuilder, StringBuffer usw.)!

Quellcode:

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

Anwendungsbeispiel:

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

die Eingabe von Dollar ist ganz einfach:

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

PS: repeat funktioniert auch für Array, List, Set usw

verwenden Sie nur die JRE-Klassen ( System.arraycopy ) und , um die Anzahl der temporären Objekte, die Sie schreiben können, zu minimieren .

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

EDIT

und ohne schleifen kannst du versuchen mit:

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

mit Sammlungen ist noch kürzer:

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

die erste Version gefällt mir aber trotzdem.

Wenn Sie Wert auf Geschwindigkeit legen, sollten Sie so wenig Speicher wie möglich kopieren. Daher ist es erforderlich, mit Arrays von Zeichen zu arbeiten.

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

Um die Geschwindigkeit zu testen, sieht eine ähnliche optimale Methode mit StirngBuilder folgendermaßen aus:

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 zum 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 der Lauf ergibt sich aus meinem System:

elapsed repeatString: 6006571
elapsed repeatStringSB: 9064937

Beachten Sie, dass der Test für die Schleife auf JIT abzielt und optimale Ergebnisse liefert.

Nicht die kürzeste, aber (glaube ich) der schnellste Weg ist, den StringBuilder zu benutzen:

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

aus Gründen der Lesbarkeit und Portabilität:

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

Wenn Sie sich Sorgen um die Leistung machen, verwenden Sie einfach einen StringBuilder in der Schleife und führen Sie beim Verlassen der Schleife eine .toString () aus. Schreiben Sie Ihre eigene Util-Klasse und verwenden Sie sie erneut. 5 Codezeilen max.

Probieren Sie dies 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;
}

Mit der Rekursion können Sie Folgendes tun (mit ternären Operatoren, maximal eine Zeile):

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

Ich weiß, es ist hässlich und wahrscheinlich nicht effizient, aber es ist eine Zeile!

Einfache Schleife

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

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

Ich genieße diese Frage wirklich. Es gibt viel Wissen und Stile. Also kann ich es nicht verlassen, ohne meinen Rock and Roll zu zeigen;)

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

Gefällt es dir

Trotz Ihres Wunsches, keine Schleifen zu verwenden, sollten Sie 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, eine for-Schleife nicht zu verwenden, sind nicht gut. Als Antwort auf Ihre Kritik:

1. Welche Lösung Sie auch verwenden, sie wird mit ziemlicher Sicherheit länger dauern. Bei Verwendung einer vorgefertigten Funktion wird diese nur unter mehr Deckungen verstaut.
2. Jemand, der Ihren Code liest, muss herausfinden, was Sie in dieser Nicht-for-Schleife tun. Da eine for-Schleife der idiomatische Weg ist, dies zu tun, wäre es viel einfacher, herauszufinden, ob Sie dies mit einer for-Schleife getan haben.
3. Ja, vielleicht fügt jemand etwas Kluges hinzu, aber indem Sie eine for-Schleife vermeiden , tun Sie sind etwas Kluges . Das ist, als würde man sich absichtlich in den Fuß schießen, um nicht versehentlich in den Fuß zu schießen.
4. Off-by-One-Fehler sind auch mit einem einzigen Test unglaublich einfach zu erkennen. Angesichts der Tatsache, dass Sie Ihren Code testen sollten, sollte es einfach sein, einen einzelnen Fehler zu beheben und abzufangen. Und es ist erwähnenswert, dass der obige Code keinen Fehler enthält, der nur einmal vorkommt. Denn Schleifen sind gleichermaßen einfach richtig zu machen.
5. Verwenden Sie also keine Variablen erneut. Das ist nicht die Schuld der for-Schleife.
6. Dies gilt auch für die von Ihnen verwendete Lösung. Und wie ich vorher bemerkt habe; Ein Bug-Jäger erwartet wahrscheinlich, dass Sie dies mit einer for-Schleife tun, so dass er es leichter findet, wenn Sie eine for-Schleife verwenden.

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ß sein, kann in diese Klasse eingefügt werden und kann kopiert und in eine Utility-Klasse in Ihrem Projekt eingefügt werden.

    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, einfach den oben genannten Code oder eine der Antworten hier zu verwenden. Aber commons lang ist einfach zu groß, wenn es sich um ein kleines Projekt handelt

public static String rep(int a,String k)

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

Sie können diese rekursive Methode für Ihr gewünschtes Ziel verwenden.

Ich habe eine rekursive Methode entwickelt, die genau das macht, was Sie wollen.

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

ich habe die gleiche Antwort auf Kann ich Zeichenfolgen in Java multiplizieren, um Sequenzen zu wiederholen?