Most efficient way to fill a String with a specified length with a specified character?

Question

Basically given an int, I need to generate a String with the same length containing only the specified character. Related question here, but it relates to C# and it does matter what's in the String.

This question, and my answer to it are why I am asking this one. I'm not sure what's the best way to go about it performance wise.

Example

Method signature:

String getPattern(int length, char character);

Usage:

//returns "zzzzzz"
getPattern(6, 'z');

What I've tried

String getPattern(int length, char character) {
    String result = "";
    for (int i = 0; i < length; i++) {
        result += character;
    }
    return result;
}

Is this the best that I can do performance-wise?

Answer 1

You should use StringBuilder instead of concatenating chars this way. Use StringBuilder.append().

StringBuilder will give you better performance. The problem with concatenation the way you are doing is each time a new String (string is immutable) is created then the old string is copied, the new string is appended, and the old String is thrown away. It's a lot of extra work that over a period of type (like in a big for loop) will cause performance degradation.

Answer 2

StringUtils from commons-lang or Strings from guava are your friends. As already stated avoid String concatenations.

StringUtils.repeat("a", 3) // => "aaa"
Strings.repeat("hey", 3) // => "heyheyhey"

Answer 3

Use primitive char arrays & some standard util classes like Arrays

public class Test {
    static String getPattern(int length, char character) {
        char[] cArray = new char[length];
        Arrays.fill(cArray, character);
//      return Arrays.toString(cArray);
        return new String(cArray);
    }

static String buildPattern(int length, char character) {
    StringBuilder sb= new StringBuilder(length);
    for (int i = 0; i < length; i++) {
        sb.append(character);
    }
    return sb.toString();
}

public static void main(String args[]){
    long time = System.currentTimeMillis();
    getPattern(10000000,'c');
    time = System.currentTimeMillis() - time;
    System.out.println(time);           //prints 93
    time = System.currentTimeMillis();
    buildPattern(10000000,'c');
    time = System.currentTimeMillis() - time;
    System.out.println(time);          //prints 188
}

}

EDIT Arrays.toString() gave lower performance since it eventually used a StringBuilder, but the new String did the magic.

Answer 4

Yikes, no.

A String is immutable in java; you can't change it. When you say:

result += character;

You're creating a new String every time.

You want to use a StringBuilder and append to it, then return a String with its toString() method.

Answer 5

I think it would be more efficient to do it like following,

String getPattern(int length, char character) 
        {
            char[] list = new char[length];
            for(int i =0;i<length;i++)
            {
                list[i] = character;
            }
            return new string(list);
        }

Answer 6

Concatenating a String is never the most efficient, since String is immutable, for better performance you should use StringBuilder, and append()

String getPattern(int length, char character) {
    StringBuilder sb= new StringBuilder(length)
    for (int i = 0; i < length; i++) {
        sb.append(character);
    }
    return sb.toString();
}

Answer 7

Performance-wise, I think you'd have better results creating a small String and concatenating (using StringBuilder of course) until you reach the request size: concatenating/appending "zzz" to "zzz" performs probably betters than concatenating 'z' three times (well, maybe not for such small numbers, but when you reach 100 or so chars, doing ten concatenations of 'z' followed by ten concatenations of "zzzzzzzzzz" is probably better than 100 concatenatinos of 'z').

Also, because you ask about GWT, results will vary a lot between DevMode (pure Java) and "production mode" (running in JS in the browser), and is likely to vary depending on the browser.

The only way to really know is to benchmark, everything else is pure speculation.
And possibly use deferred binding to use the most performing variant in each browser (that's exactly how StringBuilder is emulated in GWT).