Question

As a sample, I am developing a simple MySortedSet in java which implements SortedSet interface. It is backed up with a simple array which is E[] array.

I have several questions regarding that:

This is the class: (I am not writing entire code, instead of related parts)

public class MySortedSet<E> implements SortedSet<E>, Iterator<E> {

 private E[] array;
 private Comparator<? super E> _comparator;
 private int size = 0;
 private int capacity;

 @SuppressWarnings("unchecked")
 public MySortedSet() {
    this.capacity = 10;
    this.array = (E[]) new Object[this.capacity];
    // this.array = Array.newInstance(Class<E> var,int size);
    // We have to get Class<E> from outside caller.
 }
}

Since it accepts all sort of type from primitive to reference types etc. I am not really sure when removing an item, assigning null is a good way in place of the removed item. Since Java initializes primitive types with 0. So null only works for reference types.

Below is probably very bad design:

@Override
public boolean remove(Object o) {
    int indexOfElement = this.find(o);
    boolean removed = false;
    if (indexOfElement != -1) {
        this.array[indexOfElement] = null;
        removed = true;
    }
    return removed;
}

Can someone tell me what the best way is to remove an element from an array?

Edit:

Honestly what I am thinking to remove an element from an simple array is like copy the entire array without the removed item into a whole new array but I am not sure how efficient it would be in terms of performance and etc.

Answer 1

It kinda depends on the context of how you want to use your array. For example, if you are going to be iterating over the array and using the contents of it for standard methods like Arrays.sort(), they might generate NullPointerExceptions if you have null values in your array.

If you really want to remove items from an array in a safe way, I’d suggest changing your array to an ArrayList like this…

ArrayList<Object> list = new ArrayList<Object>();
list.add(object);
list.remove(object);

As this will actually remove the item from the list completely – no nulls or anything will remain, and performing methods like length() will return a real value.

For instances when I have used an array, I set the value to null, and ensure that all iterations over the array check that value != null before I try to query it. After setting the nulls for the removed items, I usually loop over the array and manually sort all the nulls to the end of the array, and then do System.arraycopy() to resize the array. This will leave you with a new array of the correct size, with all items in it except for the removed ones. However, I suggest this only if you really must use an array, as it is slower and introduces much greater potential for errors and NullPointerExceptions.

Alternatively, if you’re not worried about sort-order, you can simple move the last item in the array over the top of the item you want to remove, and keep a count of the real array size. For example…

Object[] array = new Object[20];
int realSize = 15; // real number of items in the array

public void remove(int arrayIndex){
    array[arrayIndex] = array[realSize-1];
    realSize--;
}

This method removes an item in the array by ‘replacing’ it with the item in the last position of the array – its very quick and pretty to implement, if you don’t care about sort order.