Whats the best way to concat Strings in java? As Java code is run on JVM and not on OS itself, why is there a huge difference in performance?

Question

I was trying to figure out best way to concatenate Strings in java. So I tested three approaches and was surprised by the results. These are the three approaches

private static String test1(String delimiter, String... data) {
    StringBuilder sb = new StringBuilder();
    for (String s : data) {
        sb.append(s);
        sb.append(delimiter);
    }
    return sb.replace(sb.length() - delimiter.length(), sb.length(), "").toString();
}

private static String test2(String delimiter, String... data) {
    String join = "";
    for(String s : data)
        join += s + delimiter;
    return join.substring(0, join.length() - delimiter.length());
}

private static String test3(String delimiter, String... data) {
    return String.join(delimiter, data);
}

tested this input with and "," as delimiter:

String[] data = new String[100000];
Arrays.fill(data, "*");

Test bench: Core i5 2.2ghz, 8gb ram, 256gb ssd, Windows 7 Results averaging around:

test1 -> 10ms
test2 -> 18038ms
test3 -> 17341ms

test2 result is obvious, but test3 should have performed nearly as good as test1 as it is roughly the same code underneath. So I tested with another bench and was surprised again.

Test bench2: Core i5 1.6ghz, 4gb ram, 128gb ssd, OSX El-Capitan

Results averaging around:

test1 -> 9ms
test2 -> 7171ms
test3 -> 9ms

What is the reason for this strange behavior? And why is it that lower specs of bench2 performing better(In case of test2)?

My question is not about StringBuilder vs String concat. It's why is there a huge difference in running times of same code on different OSes? String.join(....) is taking as much time as String concat on windows and StringBuilder on OSX

public static void main(String[] args) {
    String[] data = new String[100000];
    Arrays.fill(data, "*");

    long now = System.currentTimeMillis();
    test1(",", data);
    System.out.println("test1->" + (System.currentTimeMillis() - now) + "ms");

    now = System.currentTimeMillis();
    test2(",", data);
    System.out.println("test2->" + (System.currentTimeMillis() - now) + "ms");

    now = System.currentTimeMillis();
    test3(",", data);
    System.out.println("test3->" + (System.currentTimeMillis() - now) + "ms");
}

private static String test1(String delimiter, String... data) {
    StringBuilder sb = new StringBuilder();
    for (String s : data) {
        sb.append(s);
        sb.append(delimiter);
    }
    return sb.replace(sb.length() - delimiter.length(), sb.length(), "").toString();
}

private static String test2(String delimiter, String... data) {
    String join = "";
    for(String s : data)
        join += s + delimiter;
    return join.substring(0, join.length() - delimiter.length());
}

private static String test3(String delimiter, String... data) {
    return String.join(delimiter, data);
}

I am pretty sure that the OS is not irrelevant. The JVM reads the bytecode, but in the end it is still the kernel that does the real computation. — RaminS, Mar 28 '16 at 17:57
@Gendarme - I'm not sure it's the *OS* that's doing the computation... — Oliver Charlesworth, Mar 28 '16 at 18:02
How are you doing benchmarking? Doing _any_ kind of measurement of Java performance is _really, really hard._ — Louis Wasserman, Mar 28 '16 at 18:04
@SLaks how does too many instances effect performance on two different OSes. If that's the reason then both should perform poorly right? — Haunter, Mar 28 '16 at 18:26
@KrishnaSaiU then your measurements are almost certainly badly misleading. — Louis Wasserman, Mar 28 '16 at 18:33
@LouisWasserman what's the appropriate way to do it? And why is it misleading? — Haunter, Mar 28 '16 at 18:34
The only realistically reliable way to do benchmarking like this in Java is to use a tool like JMH, that can account properly for the JIT, for garbage collection and allocation, warming up your code, etc. — Louis Wasserman, Mar 28 '16 at 18:36
@KrishnaSaiU please, PLEASE read more about Java benchmarking. This is pretty elementary, and almost certainly is due to warming up + JIT issue that Louis W pointed out. All you are measuring between OSes/platforms are differences between those aspects. — StaxMan, Mar 28 '16 at 18:40

Whats the best way to concat Strings in java? As Java code is run on JVM and not on OS itself, why is there a huge difference in performance?

0 Answers0