Szukam prostej wspólnej metody lub operatora, który pozwala mi powtarzać niektóre ciągi n razy. Wiem, że mógłbym to napisać za pomocą pętli for, ale chciałbym unikać pętli w razie potrzeby i gdzieś powinna istnieć prosta metoda bezpośrednia.

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

repeated.equals("abcabcabc");

Związany z:

powtórz ciąg javascript Utwórz NSString, powtarzając kolejny ciąg znaków określoną liczbę razy

Edytowane

Staram się unikać pętli, gdy nie są one całkowicie konieczne, ponieważ:

1. Zwiększają liczbę wierszy kodu, nawet jeśli są ukryte w innej funkcji.

2. Ktoś czytający mój kod musi dowiedzieć się, co robię w pętli for. Nawet jeśli jest komentowany i ma sensowne nazwy zmiennych, wciąż muszą się upewnić, że nie robi nic „mądrego”.

3. Programiści uwielbiają umieszczać sprytne rzeczy w pętlach, nawet jeśli piszę to, aby „robić tylko to, co jest przeznaczone”, co nie wyklucza, że ​​ktoś przyjdzie i doda kilka dodatkowych sprytnych „poprawek”.

4. Bardzo często łatwo się pomylić. Pętle zawierające indeksy zwykle generują jeden błąd.

5. W przypadku pętli często ponownie używaj tych samych zmiennych, zwiększając szansę naprawdę trudnego znalezienia błędów dotyczących zakresu.

6. W przypadku pętli zwiększ liczbę miejsc, w których łowca błędów musi szukać.

String::repeat

". ".repeat( 7 )  // Seven period-with-space pairs: . . . . . . . 

Nowością w Javie 11 jest metoda, String::repeatktóra wykonuje dokładnie to, o co prosiłeś:

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

Jego Javadoc mówi:

/**
 * 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
 */ 

Oto najkrótsza wersja (wymagana Java 1.5+):

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

Gdzie njest ile razy chcesz powtórzyć ciąg i sjest ciąg do powtórzenia.

Nie wymaga importu ani bibliotek.

Jeśli używasz Java <= 7 , jest to tak zwięzłe, jak to możliwe:

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

W Javie 8 i nowszych istnieje bardziej czytelny sposób:

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

Wreszcie, w Javie 11 i nowszych, istnieje nowa repeat​(int count)metoda specjalnie dla tego ( link )

"abc".repeat(12);

Alternatywnie, jeśli twój projekt korzysta z bibliotek Java, istnieje więcej opcji.

Dla Apache Commons :

StringUtils.repeat("abc", 12);

W przypadku Google Guava :

Strings.repeat("abc", 12);

Commons Lang StringUtils.repeat ()

Stosowanie:

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

repeated.equals("abcabcabc");

Java 8 String.joinzapewnia prosty sposób na zrobienie tego w połączeniu z Collections.nCopies:

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

Oto sposób na zrobienie tego przy użyciu tylko standardowych funkcji String i bez wyraźnych pętli:

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

Jeśli jesteś podobny do mnie i chcesz korzystać z Google Guava, a nie Apache Commons. Możesz użyć metody repeat w klasie Struny Guava.

Strings.repeat("-", 60);

Z java-8, możesz także użyć Stream.generate.

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

w razie potrzeby możesz owinąć go prostą metodą narzędziową:

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

Więc chcesz uniknąć pętli?

Oto masz:

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

(oczywiście wiem, że to brzydkie i nieefektywne, ale nie ma pętli :-p)

Chcesz, żeby było to prostsze i ładniejsze? użyj jython:

s * 3

Edycja : zoptymalizujmy to trochę :-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 : Zrobiłem szybki i brudny test porównawczy dla 4 głównych alternatyw, ale nie mam czasu, aby uruchomić go kilka razy, aby uzyskać środki i zaplanować czasy dla kilku danych wejściowych ... Więc oto kod, jeśli ktoś chce spróbować tego:

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

Wymaga 2 argumentów, pierwszy to liczba iteracji (każda funkcja działa z czasami powtarzania arg od 1..n), a drugi to ciąg do powtórzenia.

Jak na razie szybka kontrola czasów z różnymi danymi wejściowymi pozostawia w rankingu coś takiego (lepiej na gorsze):

1. Iteracyjna aplikacja StringBuilder (1x).
2. Rekurencyjne wywołania log2 konkatenacji (~ 3x).
3. Rekurencyjne wywołania liniowe konkatenacji (~ 30x).
4. Iatacyjna konkatenacja liniowa (~ 45x).

Nigdy bym nie zgadł, że funkcja rekurencyjna była szybsza niż forpętla: -o

Baw się dobrze (ctional xD).

Zawiera mniej znaków niż twoje pytanie

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

w oparciu o odpowiedź fortrana jest to wersja wielokrotnego użytku, która korzysta z 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();
}

używanie Dollara jest proste jak pisanie:

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

PS: powtarzanie działa również dla tablicy, listy, zestawu itp

Chciałem, aby funkcja utworzyła rozdzieloną przecinkami listę znaków zapytania do celów JDBC, i znalazłem ten post. Postanowiłem więc wziąć dwa warianty i sprawdzić, który z nich działa lepiej. Po milionie iteracji odmiana ogrodowa StringBuilder zajęła 2 sekundy (fun1), a tajemnicza, bardziej optymalna wersja (fun2) zajęła 30 sekund. Po co znów być tajemniczym?

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

Rozwiązanie OOP

Niemal każda odpowiedź proponuje funkcję statyczną jako rozwiązanie, ale myśląc o obiektach (dla celów ponownego użycia i przejrzystości) wymyśliłem rozwiązanie poprzez delegację poprzez interfejs CharSequence (który otwiera także użyteczność na zmiennych klasach CharSequence).

Poniższej klasy można używać zarówno z Separator-String / CharSequence, jak i bez niej, a każde wywołanie funkcji „toString ()” tworzy końcowy powtarzany ciąg. Input / Separator nie są ograniczone tylko do String-Class, ale mogą być każdą klasą, która implementuje CharSequence (np. StringBuilder, StringBuffer itp.)!

Kod źródłowy:

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

Przykład użycia:

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

Przykładowy wynik:

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

używając tylko klas JRE ( System.arraycopy ) i próbując zminimalizować liczbę obiektów tymczasowych, możesz napisać coś takiego:

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

EDYTOWAĆ

i bez pętli możesz wypróbować:

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

EDYCJA 2

korzystanie z kolekcji jest jeszcze krótsze:

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

jednak nadal lubię pierwszą wersję.

Nie najkrótszy, ale (myślę) najszybszym sposobem jest użycie 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();
  }

Jeśli zależy Ci na szybkości, powinieneś zużywać jak najmniej kopii do pamięci. Dlatego wymagana jest praca z tablicami znaków.

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

Aby przetestować prędkość, podobna optymalna metoda przy użyciu StirngBuilder wygląda następująco:

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

i kod do przetestowania:

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

}

A oto wyniki z mojego systemu:

elapsed repeatString: 6006571
elapsed repeatStringSB: 9064937

Zauważ, że testem pętli jest uruchomienie JIT i uzyskanie optymalnych wyników.

ze względu na czytelność i przenośność:

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

Jeśli martwisz się wydajnością, po prostu użyj StringBuilder wewnątrz pętli i wykonaj .toString () na wyjściu z pętli. Heck, napisz własną klasę util i użyj jej ponownie. 5 linii kodu maks.

Naprawdę podoba mi się to pytanie. Jest dużo wiedzy i stylów. Więc nie mogę tego zostawić bez pokazania mojego rock and rolla;)

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

Czy lubisz to?

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

Prosta pętla

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

Wypróbuj to:

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

Używając rekurencji, możesz wykonać następujące czynności (używając operatorów trójskładnikowych, maksymalnie jedna linia):

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

Wiem, jest brzydka i prawdopodobnie nieefektywna, ale to jedna linia!

proste jednoliniowe rozwiązanie:
wymaga Java 8

Collections.nCopies( 3, "abc" ).stream().collect( Collectors.joining() );

Mimo że nie chcesz używać pętli, myślę, że powinieneś użyć pętli.

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

Powody, dla których nie używasz pętli for, nie są dobre. W odpowiedzi na twoją krytykę:

1. Każde zastosowane rozwiązanie prawie na pewno będzie dłuższe. Korzystanie z wbudowanej funkcji powoduje, że jest ona umieszczana tylko pod większą ilością osłon.
2. Ktoś czytający twój kod będzie musiał dowiedzieć się, co robisz w tym non-for-loop. Biorąc pod uwagę, że pętla for jest idiomatycznym sposobem na zrobienie tego, o wiele łatwiej byłoby dowiedzieć się, czy zrobiłbyś to z pętlą for.
3. Tak ktoś może dodać coś mądrego, ale poprzez unikanie pętli for ty się robi coś mądrego . To tak, jakby celowo strzelać sobie w stopę, aby uniknąć przypadkowego wystrzelenia w stopę.
4. Błędy jednorazowe są również zaskakująco łatwe do wykrycia za pomocą jednego testu. Biorąc pod uwagę, że powinieneś testować swój kod, błąd off-by-one powinien być łatwy do naprawienia i wykrycia. I warto zauważyć: powyższy kod nie zawiera błędu „jeden po drugim”. Pętle są równie łatwe do zrobienia.
5. Więc nie używaj ponownie zmiennych. To nie jest wina pętli for.
6. Ponownie, podobnie jak każde zastosowane rozwiązanie. I jak zauważyłem wcześniej; Łowca błędów prawdopodobnie spodziewa się, że zrobisz to z pętlą for, więc łatwiej będzie ci go znaleźć, jeśli użyjesz pętli for.

Jeśli znasz tylko długość ciągu wyjściowego (i może nie być podzielna przez długość ciągu wejściowego), użyj tej metody:

static String repeat(String s, int length) {
    return s.length() >= length ? s.substring(0, length) : repeat(s + s, length);
}

Demo użycia:

for (int i = 0; i < 50; i++)
    System.out.println(repeat("_/‾\\", i));

Nie używaj z pustymi si length> 0, ponieważ w tym przypadku nie można uzyskać pożądanego wyniku.

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

nie musi być nawet tak duży, można go w to przekształcić i można go skopiować i wkleić do klasy użytkowej w projekcie.

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

Więc e5, myślę, że najlepszym sposobem na to byłoby po prostu użycie wyżej wspomnianego kodu lub dowolnej z odpowiedzi tutaj. ale wspólny język jest po prostu zbyt duży, jeśli jest to mały projekt

Stworzyłem metodę rekurencyjną, która robi to samo, co chcesz .. możesz użyć tego ...

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

mam tę samą odpowiedź na Czy mogę pomnożyć ciągi w Javie, aby powtarzać sekwencje?

public static String rep(int a,String k)

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

Możesz użyć tej metody rekurencyjnej do osiągnięcia pożądanego celu.