Question

I’m staring at a profile where one of the CPU hot-spots is a function that consists of cloning a final static int[]. You might ask, ‘Why?’ the callers use the results as the starting points of a hashing process.

In other words, the code needs to do (logically):

1. make a new array
2. get the hash seeds (as many as the size of the array)
3. put values in the new array calculated from the hash seeds. That’s an iterative
   algorithm, so it’s advantageous to have the seeds start out in the array — and thus the idea of starting with a clone of the array of seeds.

Before I either give up or start wrting microbenchmarks, I’m posting this question in case anyone has any special knowledge of the what’s under the hood with clone() versus Arrays.copyOf versus just new and an arraycopy.

Answer 1

Arrays.copyOf uses System.arraycopy but adds some boundchecks first

public static int[] copyOf(int[] original,
    int newLength) 
{
        if (0 < = newLength) {
            return copyOfRange(original, 0, newLength);
        }
        throw new NegativeArraySizeException();
}


public static int[] copyOfRange(int[] original,
    int start,
    int end) 
{
        if (start < = end) {
            if (original.length  >= start && 0 < = start) {
                int length = end - start;
                int copyLength = Math.min(length, original.length - start);
                int[] copy = new int[length];
                System.arraycopy(original, start, copy, 0, copyLength);
                return copy;
            }
            throw new ArrayIndexOutOfBoundsException();
        }
        throw new IllegalArgumentException();
}

I got this from http://www.docjar.com/docs/api/java/util/Arrays.html so it might be marginally better to use this than the Arrays.copyOf

int[] newone = new int[orig.length];
System.arraycopy(orig, 0, newone , 0, orig.length);

though really it might be best to keep the arrays and reuse them after they are done with them