Java merge sort implementation Is this a good implementation?

static int[] mergeSort(int[] arr) {
    if (arr.length &lt;= 1) {
        return arr;
    }

    int[] left, right;

    left = Arrays.copyOfRange(arr, 0, arr.length / 2);
    right = Arrays.copyOfRange(arr, arr.length / 2, arr.length);

    left = mergeSort(left);
    right = mergeSort(right);

    return merge(left, right, arr);

}

private static int[] merge(int[] left, int[] right, int result[]) {

    int i = 0, j = 0, z = 0;

    while (i &lt; left.length &amp;&amp; j &lt; right.length) {
        if (left[i] &lt;= right[j]) {
            result[z++] = left[i++];

        } else {
            result[z++] = right[j++];

        }
    }

    while (i &lt; left.length) {
        result[z++] = left[i++];

    }
    while (j &lt; right.length) {
        result[z++] = right[j++];

    }
    printArr(result);
    return result;

}
static int[] mergeSort(int[] arr) {



If you want to call it array, please go ahead and write out the name.  

Personally, I'd prefer data or numbers as names, but that may just be me.  


    int[] left, right;

    left = Arrays.copyOfRange(arr, 0, arr.length / 2);
    right = Arrays.copyOfRange(arr, arr.length / 2, arr.length);



While this will work, consider 

    int[] left = Arrays.copyOfRange(arr, 0, arr.length / 2);
    int[] right = Arrays.copyOfRange(arr, arr.length / 2, arr.length);


It's actually slightly shorter in this case, as int[] is shorter than left, right;.  But even if it were longer, it is easier to follow with the declaration and initialization on the same line.  

    int midpoint = arr.length / 2;


This could make it clearer why you are passing around arr.length / 2 if you replace occurrences with midpoint.  


    int i = 0, j = 0, z = 0;



I would find this easier to read as either 

    int i = 0,
        j = 0,
        z = 0;


or 

    int i = 0;
    int j = 0;
    int z = 0;


One initialization per line.  


    printArr(result);



This looks like debugging code to me.  If so, it should have been removed before review.  

I don't have any real comments on the algorithm itself beyond what people said in the comments.  You might be able to bring down the memory usage if you tried hard enough, but it shouldn't generally matter.  This is a more elegant version and less susceptible to bugs if you aren't memory bound.  

You may be doing this just as an exercise (you can use the reinventing-the-wheel tag to indicate this) or for some other reason.  In practice, the standard Arrays.sort implementation is good enough for most needs.  You wouldn't normally need to roll your own.