从数组中删除元素，然后减小数组大小的最有效方法

Question

Say I have an array of 10 elements. Another part of my program determines I must remove the item at index 4.

What is the most efficient method to remove the item and shorten the array?

I wrote the following method, however it does not seem to work properly. Am I missing something, for example if the index to remove is 0? The method is called by sending an array and the index to be removed.

I realize there are Array Lists and other types of lists. However this is an assignment for a programming course and MUST use ARRAYs.

//Removes the index from the array and returns the array.
    NumberTile[] removeAndTrim(NumberTile[] array, int index){
        NumberTile[] save = array;
        array = new NumberTile[save.length-1];
        for (int i=0; i<index; i++){
            array[i]=save[i];
        }//end for loop
        for (int j=index; j<save.length-1; j++){
            array[j]=save[(j+1)];
        }
        return array;
    }//end removeAndTrim

Answer 1

Your method is the most efficient possible assuming this is an exercise where you are not allowed to use libraries, utility classes like arraylist or System.arraycopy. Reasoning:

• You can't avoid constructing a new array since a) you need one that is one element shorter and b) Java arrays are fixed size so you can't change the existing one
• You need to copy length-1 elements in order to populate the new array. Doing this in a tight loop is the fastest you can do in pure Java.

As a style point, you should probably call the new array "result" or somthing similar and avoid the fiddling around with trying to save the array. This is pointless - you can't alter the input parameter.

Note that your function needs to be used as follows:

NumberTile[] newArray=removeAndTrim(oldArray,index);

Answer 2

public NumberTile[] removeAndTrim(NumberTile[] a, int index){
    NumberTile[] result = new NumberTile[a.length-1];
    for (int i = 0; i < result.length; i++){
       result[i] = a[((i < index) ? i : i + 1)];
    }
    return result;
}

Your most efficient way would be one loop / traversal and one array creation.
(Without using arraycopy that is).

Note: This doesn't alter the values of the parameter array at all, just returns a new one.

Answer 3

NumberTile[] removeAndTrim(NumberTile[] array, int removeIndex) {
    NumberTile[] newArray = new NumberTile[array.length - 1];
    for (int i = 0; i < removeIndex; i++) {
        newArray[i] = array[i];
    }
    for (int i = removeIndex + 1; i < array.length - 1; i++) {
        newArray[i] = array[i + 1];
    }
    return newArray;
}