Usage of StringBuilder for returning copies of a string

Question

Given a string and a non-negative int n, we'll say that the front of the string is the first 3 chars, or whatever is there if the string is less than length 3. Return n copies of the front:

frontTimes("Chocolate", 2) → "ChoCho"
frontTimes("Chocolate", 3) → "ChoChoCho"
frontTimes("Abc", 3) → "AbcAbcAbc"
frontTimes("X", 3) → "XXX"

I've solved above problem using following code but I'm using a new StringBuilder to store intermediate string result. Does it really needed can I optimize and remove the for loop in the else?

public String frontTimes(String str, int n) {

        StringBuilder sb = new StringBuilder(str);
        StringBuilder newsb = new StringBuilder();

        if(sb.length() >= 3)
        {
            for(int i = 0; i < n; i++)
            {
                newsb.append(sb.substring(0,3));
            }

            return newsb.toString(); 
        }
        else
        {
            for(int i = 0; i < n; i++)
            {
                newsb.append(sb.toString());
            }

            return newsb.toString();

        }

    }

Answer 1

I'd just like to make a slight change to the code. When you are instantiating a StringBuilder, you have the opportunity to specify the capacity of it. Using this constructor, we can avoid having it resized more than necessary.

public String frontTimes(String str, int n) {
    StringBuilder stringBuilder = new StringBuilder(3 * n);
    if (str.length() > 3) {
        str = str.substring(0, 3);
    }
    for (int i = 0; i < n; i++) {
        stringBuilder.append(str);
    }
    return stringBuilder.toString();
}

Note how many times that 3 is declared? Would be better to extract that to a constant, or even better, a parameter. And with a few other changes to the above (as suggested by @rolfl in chat):

public String frontTimes(final String str, final int frontLength, final int times) {
    String copyString = str.length() > frontLength ? str.substring(0, frontLength) : str;
    StringBuilder stringBuilder = new StringBuilder(copyString.length() * times);
    for (int i = 0; i < times; i++) {
        stringBuilder.append(copyString);
    }
    return stringBuilder.toString();
}

Answer 2

I am a fan of using primitives. In this case, the performance benefit would be minimal, but the number of copies would actually be less.....

In reality, I would probably use the StringBuilder approach similar to what other answers have given (+1 to them all), but you should be aware that the following code is likely faster, has fewer iterations through the loop, and will scale better..... if you ever need to make millions of copies... ;-) (now here with a cheesy test case in ideone too)

/**
 * Using the input source string, duplicate its prefix the specified count
 * times.
 * @param source       The source string containing the prefix
 * @param prefixLength The length of the prefix to use (or the whole string
 *                     if the prefix is larger than the String)
 * @param count        the number of times to repeat the prefix.
 * @return the resulting duplicated string, or an empty string if the source
 *         is invalid or the count or prefix length is zero
 */
public static String duplicatePrefix(final String source, final int prefixLength, final int count) {
    if (source == null || source.length() == 0 || prefixLength <= 0 || count <= 0) {
        return "";
    }

    final int actual = Math.min(source.length(), prefixLength);
    final int size = actual * count;
    final char[] results = new char[size];
    // copy the first prefix to the output
    source.getChars(0, actual, results, 0);
    // duplicate the previously populated chars as often as needed.
    int currentpos = actual;
    while (currentpos < size) {
        // copy as much as you can, limited by the available space to copy to.
        System.arraycopy(results, 0, results, currentpos, Math.min(currentpos, size - currentpos));
        // double the current position
        currentpos <<= 1;
    }
    return new String(results);
}

Note that the loop in the above code will iterate only \$\log(count)\$ times where, which can be a significant saving in the event that count is large, though the ArrayCopy is still an \$O(n)\$ operation, so it is a toss up as to whether it will improve the speed at all... it will need some benchmarking.

Answer 3

I think the StringBuilder sb isn't necessary.

public String frontTimes(String str, int n)
{
    StringBuilder newsb = new StringBuilder();

    if (str.Length >= 3) str = str.substring(0, 3);

    for (int i = 0; i < n; i++)
    {
        newsb.append(str);
    }

    return newsb.ToString();
}