Java's varargs performance

Question

Coding i came around to check for the vararg performance of Java.

I write following test code:

public class T {

    public static void main(String[         


        

Answer 1

I refactored some of the code. I use int now instead of String cause strings end in a pool and are immutable, and I don't know how that influences the compiler optimizations.

Also I recreate the values so they won't be constants which might also influence compiler optimizations.

And I do something with the methods, also against compiler optimizations.

public class Test {


    static int n = 100_000_000;
    static int[] all_string = new int[n*1*5];
    static int all_strings_index = 0;



    public static void main(String[] args) {

        while(true) {
    
            all_strings_index = 0;
    
            int s1 = (int) System.nanoTime();
            int s2 = (int) System.nanoTime();
            int s3 = (int) System.nanoTime();
            int s4 = (int) System.nanoTime();
            int s5 = (int) System.nanoTime();
    
            long t = System.currentTimeMillis();
    
    
            t = System.currentTimeMillis();
            for (int i = 0; i < n; i++) {
                var(s1, s2, s3, s4, s5);
            }
            System.err.println("varargs    "+(System.currentTimeMillis() - t));
    
            all_strings_index = 0;
    
            t = System.currentTimeMillis();
            for (int i = 0; i < n; i++) {
                par(s1, s2, s3, s4, s5);
            }
            System.err.println("parameters "+(System.currentTimeMillis() - t));
    
    
            all_strings_index = 0;
    
            int[] arr = new int[] {s1, s2, s3, s4, s5};
    
            t = System.currentTimeMillis();
            for (int i = 0; i < n; i++) {
                var2(arr);
            }
            System.err.println("array      "+(System.currentTimeMillis() - t));
            System.err.println();
    
        }

    }

    static void par(int a1, int a2, int a3, int a4, int a5) {
        all_string[all_strings_index++] = a1;
        all_string[all_strings_index++] = a2;
        all_string[all_strings_index++] = a3;
        all_string[all_strings_index++] = a4;
        all_string[all_strings_index++] = a5;
    }

    static void var(int... a) {
        for (int s : a) {
            all_string[all_strings_index++] = s;
        }
    }

    static void var2(int[] a) {
        for (int s : a) {
            all_string[all_strings_index++] = s;
        }
    }
}

varargs    981
parameters 415
array      687

varargs    962
parameters 434
array      411

varargs    975
parameters 469
array      439

varargs    983
parameters 462
array      447

varargs    999
parameters 470
array      439

varargs    1018
parameters 475
array      455

varargs    1014
parameters 467
array      440

varargs are a lot slower.