ฉันกำลังมองหาวิธีการทั่วไปหรือผู้ประกอบการที่ช่วยให้ฉันสามารถทำซ้ำสตริงnบางครั้ง ฉันรู้ว่าฉันสามารถเขียนสิ่งนี้โดยใช้ for for loop แต่ฉันต้องการหลีกเลี่ยงการวนซ้ำเมื่อจำเป็น

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

repeated.equals("abcabcabc");

ที่เกี่ยวข้องกับ:

javascript สตริงซ้ำ สร้าง NSString โดยทำซ้ำสตริงอื่นตามจำนวนครั้งที่กำหนด

แก้ไข

ฉันพยายามหลีกเลี่ยงลูปเมื่อไม่จำเป็นอย่างสมบูรณ์เพราะ:

1. พวกเขาเพิ่มจำนวนบรรทัดของรหัสแม้ว่าพวกเขาจะซุกอยู่ในฟังก์ชันอื่น

2. ใครบางคนกำลังอ่านโค้ดของฉันจะต้องเข้าใจว่าฉันกำลังทำอะไรอยู่ แม้ว่าจะได้รับการแสดงความคิดเห็นและมีชื่อตัวแปรที่มีความหมายพวกเขายังคงต้องตรวจสอบให้แน่ใจว่าไม่ได้ทำอะไร "ฉลาด"

3. โปรแกรมเมอร์ชอบที่จะใส่สิ่งที่ฉลาดในการวนรอบแม้ว่าฉันจะเขียนถึง "ทำในสิ่งที่ตั้งใจทำเท่านั้น" นั่นไม่ได้ขัดขวางคนที่เข้ามาและเพิ่ม "แก้ไข" ที่ชาญฉลาดเพิ่มเติม

4. พวกเขามักจะผิดพลาดได้ง่ายมาก สำหรับลูปที่เกี่ยวข้องกับดัชนีมักจะเกิดจากข้อบกพร่องหนึ่งข้อ

5. สำหรับลูปมักจะนำตัวแปรเดิมมาใช้ซ้ำซึ่งเป็นการเพิ่มโอกาสในการหาข้อบกพร่องที่กำหนดขอบเขตได้ยากมาก

6. สำหรับลูปเพิ่มจำนวนสถานที่ที่นักล่าบั๊กต้องดู

String::repeat

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

ใหม่ใน Java 11เป็นวิธีการString::repeatที่ตรงตามที่คุณขอ:

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

Javadocมันพูดว่า:

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

นี่คือเวอร์ชันที่สั้นที่สุด (จำเป็นต้องใช้ Java 1.5+):

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

ที่ไหนnคือจำนวนครั้งที่คุณต้องการที่จะทำซ้ำสตริงและsเป็นสตริงที่ซ้ำ

ไม่ต้องนำเข้าหรือไลบรารี

หากคุณใช้Java <= 7นี่จะเป็น "รัดกุม" ตามที่ได้รับ:

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

ในJava 8ขึ้นไปมีวิธีที่อ่านง่ายกว่า:

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

ในที่สุดสำหรับJava 11และสูงกว่ามีrepeat​(int count)วิธีการใหม่โดยเฉพาะสำหรับเรื่องนี้ ( ลิงค์ )

"abc".repeat(12);

อีกทางหนึ่งถ้าโครงการของคุณใช้ไลบรารี java มีตัวเลือกเพิ่มเติม

สำหรับApache Commons :

StringUtils.repeat("abc", 12);

สำหรับGoogle Guava :

Strings.repeat("abc", 12);

คอมมอนส์ Lang StringUtils.repeat ()

การใช้งาน:

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

repeated.equals("abcabcabc");

Java 8's String.joinจัดเตรียมวิธีที่เป็นระเบียบเรียบร้อยในการดำเนินการร่วมกับCollections.nCopies:

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

ต่อไปนี้เป็นวิธีการใช้ฟังก์ชั่น String มาตรฐานเท่านั้นและไม่มีการวนซ้ำอย่างชัดเจน:

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

หากคุณชอบฉันและต้องการใช้ Google Guava ไม่ใช่ Apache Commons คุณสามารถใช้วิธีการซ้ำในคลาส Guava Strings

Strings.repeat("-", 60);

กับ Java-8Stream.generateคุณยังสามารถใช้

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

และคุณสามารถห่อด้วยวิธียูทิลิตี้ง่าย ๆ หากจำเป็น:

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

ดังนั้นคุณต้องการหลีกเลี่ยงการวนซ้ำ?

ที่นี่คุณมีมัน:

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

(แน่นอนฉันรู้ว่านี่น่าเกลียดและไม่มีประสิทธิภาพ แต่ไม่มีลูป :-p)

คุณต้องการให้เรียบง่ายและสวยกว่ากัน? ใช้ jython:

s * 3

แก้ไข : ลองเพิ่มประสิทธิภาพหน่อย :-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);
}

แก้ไข 2 : ฉันทำเกณฑ์มาตรฐานที่รวดเร็วและสกปรกสำหรับตัวเลือกหลัก 4 ตัว แต่ฉันไม่มีเวลารันหลาย ๆ ครั้งเพื่อให้ได้ค่าเฉลี่ยและวางแผนเวลาสำหรับอินพุตหลายตัว ... ดังนั้นนี่คือรหัสถ้าใครต้องการ ลองมัน:

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

มันใช้เวลา 2 ข้อโต้แย้งข้อแรกคือจำนวนการวนซ้ำ (แต่ละฟังก์ชั่นทำงานโดยมีเวลาทำซ้ำ arg จาก 1..n) และที่สองคือสตริงที่จะทำซ้ำ

จนถึงตอนนี้การตรวจสอบอย่างรวดเร็วของเวลาที่ทำงานด้วยอินพุตที่แตกต่างกันทำให้การจัดอันดับเป็นแบบนี้ (ดีกว่าแย่กว่า):

1. เพิ่มซ้ำ StringBuilder ผนวก (1x)
2. การเชื่อมต่อแบบเรียกซ้ำการล็อกแบบเรียกซ้ำ (~ 3x)
3. การเชื่อมโยงการเรียกซ้ำเชิงซ้อนแบบเรียกซ้ำ (~ 30x)
4. การต่อข้อมูลแบบวนซ้ำเชิงเส้น (~ 45x)

ฉันไม่เคยเดาเลยว่าฟังก์ชั่นวนซ้ำนั้นเร็วกว่าforลูป: -o

ขอให้สนุก (ctional xD)

มีอักขระน้อยกว่าคำถามของคุณ

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

ตามคำตอบของ fortranนี่เป็นเวอร์ชั่นที่ใช้ซ้ำได้ซึ่งใช้ 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();
}

การใช้Dollarนั้นง่ายเหมือนการพิมพ์:

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

PS: ทำงานซ้ำสำหรับอาร์เรย์, รายการ, ชุด, ฯลฯ

ฉันต้องการให้ฟังก์ชันสร้างรายการเครื่องหมายคำถามคั่นด้วยเครื่องหมายจุลภาคสำหรับจุดประสงค์ JDBC และพบบทความนี้ ดังนั้นฉันจึงตัดสินใจที่จะรับสองสายพันธุ์และดูว่าสายพันธุ์ใดที่ทำงานได้ดีกว่า หลังจากการทำซ้ำ 1 ล้านครั้ง StringBuilder ที่มีความหลากหลายในสวนใช้เวลา 2 วินาที (fun1) และรุ่นที่เหมาะสมที่สุดที่น่าสงสัยกว่านั้น (fun2) ใช้เวลา 30 วินาที อะไรคือจุดที่เป็นความลับอีกครั้ง?

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

เกือบทุกคำตอบเสนอฟังก์ชั่นแบบคงที่เป็นวิธีแก้ปัญหา แต่คิดว่า Object-Oriented (เพื่อนำมาใช้ใหม่ได้และมีความชัดเจน) ฉันมาพร้อมกับโซลูชันผ่านการมอบหมายผ่าน CharSequence-Interface (ซึ่งเปิดใช้งาน CharSequence-Classes

Class ต่อไปนี้สามารถใช้ได้ทั้งแบบมีหรือไม่มี Separator-String / CharSequence และการเรียกแต่ละครั้งไปที่ "toString ()" จะสร้างสตริงที่ซ้ำกันครั้งสุดท้าย Input / Separator ไม่เพียง แต่ถูก จำกัด ให้ใช้งานกับ String-Class เท่านั้น แต่ยังสามารถเป็น Class ทุกคลาสที่ใช้ CharSequence (เช่น StringBuilder, StringBuffer, ฯลฯ )!

รหัสแหล่งที่มา:

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

การใช้งานตัวอย่าง:

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

ตัวอย่างเอาท์พุท:

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

ใช้คลาส JRE เท่านั้น ( System.arraycopy ) และพยายามลดจำนวนของวัตถุ temp ที่คุณสามารถเขียนได้เช่น:

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

แก้ไข

และหากไม่มีลูปคุณสามารถลองด้วย:

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

แก้ไข 2

การใช้คอลเล็กชันนั้นสั้นกว่า:

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

แต่ฉันก็ยังชอบเวอร์ชั่นแรกอยู่

ไม่ใช่วิธีที่สั้นที่สุด แต่(ฉันคิดว่า)วิธีที่เร็วที่สุดคือใช้ 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();
  }

หากความเร็วเป็นปัญหาของคุณคุณควรใช้การคัดลอกหน่วยความจำน้อยที่สุดเท่าที่จะทำได้ ดังนั้นจึงจำเป็นต้องทำงานกับอาร์เรย์ของตัวอักษร

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

ในการทดสอบความเร็ววิธีที่ดีที่สุดที่คล้ายกันโดยใช้ StirngBuilder เป็นดังนี้:

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

และรหัสเพื่อทดสอบ:

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

}

และนี่คือผลลัพธ์การรันจากระบบของฉัน:

elapsed repeatString: 6006571
elapsed repeatStringSB: 9064937

โปรดทราบว่าการทดสอบลูปคือเตะใน JIT และมีผลลัพธ์ที่ดีที่สุด

เพื่อประโยชน์ในการอ่านและพกพา:

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

หากคุณกังวลเกี่ยวกับประสิทธิภาพการทำงานให้ใช้ StringBuilder ภายในลูปและทำ. toString () เมื่อออกจากลูป Heck เขียน Util Class ของคุณเองและนำมาใช้ซ้ำ 5 บรรทัดของรหัสสูงสุด

ฉันสนุกกับคำถามนี้จริงๆ มีความรู้และสไตล์มากมาย ดังนั้นฉันไม่สามารถออกได้โดยไม่แสดงร็อกแอนด์โรลของฉัน;)

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

คุณชอบมันไหม?

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

วนรอบง่าย

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

ลองใช้ดู

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

การใช้การเรียกซ้ำคุณสามารถทำสิ่งต่อไปนี้ได้ (โดยใช้ตัวดำเนินการแบบไตรภาคสูงสุดหนึ่งบรรทัด):

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

ฉันรู้ว่ามันน่าเกลียดและอาจไม่มีประสิทธิภาพ แต่มันเป็นหนึ่งบรรทัด!

โซลูชันหนึ่งบรรทัดที่ไม่ซับซ้อน:
ต้องการ Java 8

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

แม้ว่าคุณจะไม่ต้องการใช้ลูป แต่ฉันคิดว่าคุณควรใช้ลูป

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

เหตุผลที่คุณไม่ใช้วงวนไม่ใช่เหตุผลที่ดี ตามการวิพากษ์วิจารณ์ของคุณ:

1. ไม่ว่าคุณจะใช้วิธีแก้ปัญหาใดจะนานกว่านี้อย่างแน่นอน การใช้ฟังก์ชั่นที่สร้างไว้ล่วงหน้าจะปิดเฉพาะภายใต้การปกปิดเพิ่มเติม
2. บางคนที่อ่านรหัสของคุณจะต้องเข้าใจว่าคุณกำลังทำอะไรในวงนั้น เนื่องจาก for-loop นั้นเป็นวิธีที่ใช้สำนวนนี้มันจะง่ายกว่าถ้าคุณใช้ลูป for for loop
3. ใช่ใครบางคนอาจเพิ่มบางสิ่งที่ฉลาด แต่โดยการหลีกเลี่ยงการวนซ้ำคุณกำลังทำสิ่งที่ฉลาดทำอะไรบางอย่างฉลาดมันเหมือนกับการยิงตัวเองที่เท้าอย่างตั้งใจเพื่อหลีกเลี่ยงการยิงตัวเองที่เท้าโดยไม่ได้ตั้งใจ
4. ข้อผิดพลาดแบบ Off-by-One นั้นง่ายต่อการจับใจด้วยการทดสอบเพียงครั้งเดียว เนื่องจากคุณควรทดสอบโค้ดของคุณข้อผิดพลาดแบบออฟไลน์ควรแก้ไขและตรวจจับได้ง่าย และมันก็ควรค่าแก่การสังเกต: โค้ดข้างต้นไม่มีข้อผิดพลาดแบบออฟไลน์ สำหรับการวนซ้ำนั้นง่ายพอ ๆ กัน
5. ดังนั้นอย่าใช้ตัวแปรซ้ำ นั่นไม่ใช่ความผิดของ for-loop
6. อีกครั้งดังนั้นวิธีแก้ปัญหาใดที่คุณใช้ และอย่างที่ฉันเคยสังเกตมาก่อน นักล่าบั๊กอาจจะคาดหวังให้คุณทำเช่นนี้กับ for loop ดังนั้นพวกเขาจะหาเวลาได้ง่ายขึ้นถ้าคุณใช้ for for loop

หากคุณทราบความยาวของสตริงเอาต์พุต (และอาจไม่สามารถหารด้วยความยาวของสตริงอินพุต) ดังนั้นให้ใช้วิธีนี้:

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

สาธิตการใช้งาน:

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

อย่าใช้กับที่ว่างเปล่าsและlength> 0 เนื่องจากเป็นไปไม่ได้ที่จะได้ผลลัพธ์ตามที่ต้องการในกรณีนี้

นี่คือ 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();
    }
    }

ไม่จำเป็นต้องมีขนาดใหญ่สามารถทำสิ่งนี้ได้และสามารถคัดลอกและวางลงในคลาสยูทิลิตี้ในโครงการของคุณ

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

ดังนั้น e5 ฉันคิดว่าวิธีที่ดีที่สุดในการทำเช่นนี้ก็คือการใช้รหัสที่กล่าวถึงข้างต้นหรือคำตอบใด ๆ ที่นี่ แต่คอมมอนส์ lang มีขนาดใหญ่เกินไปถ้ามันเป็นโครงการขนาดเล็ก

ฉันสร้างวิธีเรียกซ้ำที่ทำในสิ่งเดียวกันกับที่คุณต้องการ .. รู้สึกอิสระที่จะใช้สิ่งนี้ ...

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

ฉันมีคำตอบเดียวกันกับที่ฉันสามารถคูณสตริงใน java เพื่อทำซ้ำลำดับ?

public static String rep(int a,String k)

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

คุณสามารถใช้วิธีเรียกซ้ำนี้เพื่อเป้าหมายที่คุณต้องการ