Eenvoudige manier om een ​​string te herhalen

Ik ben op zoek naar een eenvoudige commons-methode of operator waarmee ik een reeks n keer kan herhalen. Ik weet dat ik dit zou kunnen schrijven met een for-lus, maar ik wil for-lussen vermijden wanneer dat nodig is en er moet ergens een eenvoudige directe methode bestaan.

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

Gerelateerd aan:

repeat string javascript
Maak NSString door een andere string een bepaald aantal te herhalen keer

Bewerkt

Ik probeer for-loops te vermijden als ze niet helemaal nodig zijn, omdat:

  1. Ze voegen toe aan het aantal regels code, zelfs als ze zijn weggestopt in een andere functie.

  2. Iemand die mijn code leest, moet uitzoeken wat ik doe in die for-lus. Zelfs als het commentaar heeft en betekenisvolle namen van variabelen heeft, moeten ze er nog steeds voor zorgen dat het niets “slims” doet.

  3. Programmeurs houden ervan om slimme dingen in for-loops te stoppen, zelfs als ik het schrijf om “alleen te doen waarvoor het bedoeld is”, dat sluit niet uit dat iemand langskomt en een extra slimme “oplossing” toevoegt.

  4. Ze zijn vaak gemakkelijk fout te krijgen. For-loops met indexen hebben de neiging om bugs te genereren.

  5. For-lussen hergebruiken vaak dezelfde variabelen, waardoor de kans op echt moeilijk te vinden scoping-bugs groter wordt.

  6. For-loops vergroot het aantal plaatsen waar een bugjager moet zoeken.


Antwoord 1, autoriteit 100%

String::repeat

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

Nieuw in Java 11 is de methode String::repeat die precies doet waar je om vroeg:

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

Het is Javadoc zegt:

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

Antwoord 2, autoriteit 96%

Hier is de kortste versie (Java 1.5+ vereist):

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

Waarbij n het aantal keren is dat u de tekenreeks wilt herhalen en s de tekenreeks is die moet worden herhaald.

Geen import of bibliotheken nodig.


Antwoord 3, autoriteit 97%

Als u Java <= 7 gebruikt, is dit zo “beknopt” als het maar kan:

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

In Java 8 en hoger is er een meer leesbare manier:

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

Ten slotte is er voor Java 11 en hoger een nieuwe repeat?(int count)-methode speciaal voor dit doel(link)

"abc".repeat(12);

Als uw project Java-bibliotheken gebruikt, zijn er ook meer opties.

Voor Apache Commons :

StringUtils.repeat("abc", 12);

Voor Google Guava:

Strings.repeat("abc", 12);

Antwoord 4, autoriteit 92%

Commons Lang StringUtils.repeat()

Gebruik:

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

Antwoord 5, autoriteit 42%

Java 8’s String.join biedt een nette manier om dit te doen in combinatie met Collections.nCopies:

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

Antwoord 6, autoriteit 29%

Hier is een manier om het te doen met alleen standaard String-functies en geen expliciete loops:

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

Antwoord 7, autoriteit 25%

Als je op mij lijkt en Google Guava wilt gebruiken en niet Apache Commons. U kunt de herhaal methode in de Guava Strings klasse.

Strings.repeat("-", 60);

Antwoord 8, autoriteit 16%

Met , kunt u ook Stream.generate gebruiken.

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

en u kunt het indien nodig in een eenvoudige hulpprogramma-methode inpakken:

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

Antwoord 9, autoriteit 10%

Dus je wilt loops vermijden?

Hier heb je het:

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

(natuurlijk weet ik dat dit lelijk en inefficiënt is, maar het heeft geen loops :-p)

Wil je het eenvoudiger en mooier? gebruik jython:

s * 3

Bewerken: laten we het een beetje optimaliseren 😀

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: ik heb een snelle en vuile benchmark gedaan voor de 4 belangrijkste alternatieven, maar ik heb geen tijd om het meerdere keren uit te voeren om de middelen te krijgen en de tijden voor verschillende invoer uit te zetten … Dus hier is de code als iemand het wil proberen:

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

Er zijn 2 argumenten nodig, de eerste is het aantal iteraties (elke functie wordt uitgevoerd met herhalingstijden arg vanaf 1..n) en de tweede is de te herhalen string.

Tot nu toe laat een snelle inspectie van de tijden met verschillende invoer de ranglijst er ongeveer zo uit zien (beter naar slechter):

  1. Iteratieve StringBuilder-toevoeging (1x).
  2. Recursieve concatenatie log2-aanroepen (~3x).
  3. Recursieve aaneenschakeling van lineaire aanroepen (~30x).
  4. Iteratieve aaneenschakeling lineair (~45x).

Ik had nooit gedacht dat de recursieve functie sneller was dan de for-lus 😮

Veel plezier(ctional xD).


Antwoord 10, autoriteit 6%

Dit bevat minder tekens dan uw vraag

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

Antwoord 11, autoriteit 3%

gebaseerd op antwoord van fortran, dit is een recusieve versie die een StringBuilder gebruikt:

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

Antwoord 12, autoriteit 2%

het gebruik van Dollar is zo eenvoudig als typen:

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

PS: herhalen werkt ook voor array, List, Set, etc


Antwoord 13, autoriteit 2%

Ik wilde een functie om een ​​door komma’s gescheiden lijst met vraagtekens te maken voor JDBC-doeleinden en vond dit bericht. Dus besloot ik twee varianten te nemen en te kijken welke beter presteerde. Na 1 miljoen iteraties duurde de tuinvariant StringBuilder 2 seconden (fun1), en de cryptische zogenaamd meer optimale versie (fun2) duurde 30 seconden. Wat heeft het voor zin om weer cryptisch te zijn?

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

Antwoord 14, autoriteit 2%

OOP-oplossing

Bijna elk antwoord stelt een statische functie als oplossing voor, maar objectgericht denkend (voor herbruikbaarheidsdoeleinden en duidelijkheid) kwam ik met een oplossing via delegatie via de CharSequence-interface (die ook bruikbaarheid opent op veranderlijke CharSequence- lessen).

De volgende klasse kan worden gebruikt met of zonder Separator-String/CharSequence en elke aanroep van “toString()” bouwt de laatste herhaalde String op.
De Input/Separator is niet alleen beperkt tot String-Class, maar kan elke Class zijn die CharSequence implementeert (bijv. StringBuilder, StringBuffer, enz.)!

Broncode:

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

Gebruiksvoorbeeld:

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

Voorbeeld-uitvoer:

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

Antwoord 15, autoriteit 2%

alleen JRE-klassen gebruiken (System. arraycopy) en proberen te minimaliseren het aantal tijdelijke objecten dat u kunt schrijven, zoiets als:

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

BEWERKEN

en zonder loops kun je proberen met:

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

BEWERK 2

het gebruik van Collecties is nog korter :

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

maar ik vind de eerste versie nog steeds leuk.


Antwoord 16, autoriteit 2%

Niet de kortste, maar (denk ik) de snelste manier is om de StringBuilder te gebruiken:

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

Antwoord 17

Als snelheid uw zorg is, moet u zo min mogelijk geheugen kopiëren. Het is dus vereist om met arrays van tekens te werken.

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

Om de snelheid te testen, is een vergelijkbare optimale methode met StirngBuilder als volgt:

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

en de code om het te 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);
}

En hier de resultaten van de run van mijn systeem:

elapsed repeatString: 6006571
elapsed repeatStringSB: 9064937

Merk op dat de test voor lus is om JIT te activeren en optimale resultaten te behalen.


Antwoord 18

voor de leesbaarheid en draagbaarheid:

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

Antwoord 19

Als je je zorgen maakt over de prestaties, gebruik dan gewoon een StringBuilder in de lus en voer een .toString() uit bij het verlaten van de lus. Heck, schrijf je eigen Util Class en hergebruik het. 5 regels code max.


Antwoord 20

een eenvoudige éénregelige oplossing:
vereist Java 8

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

Antwoord 21

Ik vind deze vraag erg leuk. Er is veel kennis en stijlen. Dus ik kan het niet laten zonder mijn rock and roll te laten zien 😉

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

Vind je het leuk?


Antwoord 22

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

Antwoord 23

Eenvoudige lus

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

Antwoord 24

Probeer dit eens:

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

Antwoord 25

Met recursie kunt u het volgende doen (met ternaire operatoren, maximaal één regel):

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

Ik weet het, het is lelijk en waarschijnlijk niet efficiënt, maar het is één regel!


Antwoord 26

Als u alleen de lengte van de uitvoertekenreeks weet (en deze is mogelijk niet deelbaar door de lengte van de invoerreeks), gebruik dan deze methode:

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

Gebruiksdemo:

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

Niet gebruiken met lege s en length > 0, omdat het in dit geval onmogelijk is om het gewenste resultaat te krijgen.


Antwoord 27

Ondanks je wens om geen loops te gebruiken, denk ik dat je een loop moet gebruiken.

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

Uw redenen om geen for-lus te gebruiken zijn niet goed. Als reactie op uw kritiek:

  1. Welke oplossing u ook gebruikt, deze zal vrijwel zeker langer duren. Het gebruik van een vooraf gebouwde functie stopt het alleen onder meer dekens.
  2. Iemand die je code leest, zal moeten uitzoeken wat je doet in die non-for-loop. Aangezien een for-lus de idiomatische manier is om dit te doen, zou het veel gemakkelijker zijn om erachter te komen of je het met een for-lus zou doen.
  3. Ja, iemand kan iets slims toevoegen, maar door een for-lus te vermijden je doe je iets slims. Dat is hetzelfde als jezelf opzettelijk in de voet schieten om te voorkomen dat je jezelf per ongeluk in de voet schiet.
  4. Fout-by-one-fouten zijn ook geestdodend gemakkelijk op te sporen met een enkele test. Aangezien u uw code zou moeten testen, moet een fout-by-one-fout eenvoudig op te lossen en op te vangen zijn. En het is vermeldenswaard: de bovenstaande code bevat geen fout-by-one fout. For-lussen zijn even gemakkelijk goed te krijgen.
  5. Gebruik variabelen dus niet opnieuw. Dat is niet de schuld van de for-loop.
  6. Nogmaals, dat geldt ook voor welke oplossing je ook gebruikt. En zoals ik al eerder opmerkte; een bugjager verwacht waarschijnlijk dat je dit doet met een for-lus, dus ze zullen het gemakkelijker vinden als je een for-lus gebruikt.

Antwoord 28

hier is de nieuwste 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();
    }
    }

het hoeft niet eens zo groot te zijn, kan er in gemaakt worden en kan gekopieerd en geplakt worden
in een utility-klasse in uw project.

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

Dus e5, ik denk dat de beste manier om dit te doen zou zijn om gewoon de bovengenoemde code te gebruiken, of een van de antwoorden hier. maar commons lang is gewoon te groot als het een klein project is


Antwoord 29

Ik heb een recursieve methode gemaakt die hetzelfde doet als jij wilt.. voel je vrij om dit te gebruiken…

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

ik heb hetzelfde antwoord op Kan ik strings vermenigvuldigen in java om reeksen te herhalen?


Antwoord 30

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

U kunt deze recursieve methode gebruiken voor het door u gewenste doel.

LEAVE A REPLY

Please enter your comment!
Please enter your name here

2 × four =

Other episodes