Einfacher Weg zur Wiederholung einer Zeichenkette

Question

Ich suche eine einfache Commons-Methode oder einen Operator, der es mir erlaubt, eine Zeichenkette zu wiederholen n Zeiten. Ich weiß, ich könnte dies mit einer for-Schleife schreiben, aber ich möchte for-Schleifen vermeiden, wann immer es nötig ist, und eine einfache direkte Methode sollte irgendwo existieren.

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

repeated.equals("abcabcabc");

Verwandt mit:

wiederholen string javascript Erstellen von NSString durch Wiederholung einer anderen Zeichenfolge eine bestimmte Anzahl von Malen

Bearbeitet

Ich versuche, for-Schleifen zu vermeiden, wenn sie nicht unbedingt notwendig sind, denn:

1. Sie erhöhen die Anzahl der Codezeilen, auch wenn sie in einer anderen Funktion versteckt sind.

2. Jemand, der meinen Code liest, muss herausfinden, was ich in dieser for-Schleife tue. Selbst wenn der Code kommentiert ist und aussagekräftige Variablennamen hat, muss er sich vergewissern, dass er nicht irgendetwas "Schlaues" macht.

3. Programmierer lieben es, clevere Dinge in for-Schleifen einzubauen. Selbst wenn ich schreibe, dass die Schleife "nur das tut, was sie tun soll", schließt das nicht aus, dass jemand vorbeikommt und eine zusätzliche clevere "Lösung" einbaut.

4. Sie sind oft sehr leicht zu verwechseln. For-Schleifen, die Indizes beinhalten, neigen dazu, Fehler zu erzeugen, die sich um einen Fehler unterscheiden.

5. In For-Schleifen werden oft dieselben Variablen wiederverwendet, was die Wahrscheinlichkeit von schwer zu findenden Scoping-Fehlern erhöht.

6. Denn Schleifen erhöhen die Anzahl der Stellen, an denen ein Wanzenjäger suchen muss.

Answer 1

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

Answer 2

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

Strings.repeat("-", 60);

Answer 3

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

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

und Sie können sie bei Bedarf in eine einfache Dienstprogrammmethode einpacken:

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

Answer 4

Sie wollen also Schleifen vermeiden?

Hier haben Sie 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 hat keine Schleifen :-p)

Wenn Sie es einfacher und schöner haben wollen, verwenden Sie Jython:

s * 3

Editar : Lass uns das ein bisschen 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);
}

Bearbeiten2 : Ich habe einen schnellen und schmutzigen Benchmark für die 4 Hauptalternativen gemacht, aber ich habe nicht die Zeit, ihn mehrmals laufen zu lassen, um die Mittelwerte zu erhalten und die Zeiten für mehrere Eingaben aufzuzeichnen... Hier ist also der Code, falls jemand ihn ausprobieren 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();
    }
}

Sie benötigt 2 Argumente, das erste ist die Anzahl der Iterationen (jede Funktion läuft mit Wiederholungszeiten arg von 1..n) und das zweite ist die zu wiederholende Zeichenkette.

Wenn man sich die Zeiten ansieht, die mit verschiedenen Eingaben gelaufen sind, sieht die Rangliste in etwa so aus (besser bis schlechter):

1. Iterativer StringBuilder append (1x).
2. Rekursive Verkettung log2 Aufrufen (~3x).
3. Rekursive Verkettung linearer Aufrufe (~30x).
4. Iterative Verkettung linear (~45x).

Ich wäre nie auf die Idee gekommen, dass die rekursive Funktion schneller ist als die for Schleife :-o

Viel Spaß(ctional xD).

Answer 5

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