Removing an element from an Array (Java)

Question

Is there any fast (and nice looking) way to remove an element from an array in Java?

Answer 1

You can't remove an element from the basic Java array. Take a look at various Collections and ArrayList instead.

Answer 2

Sure, create another array :)

Answer 3

Nice looking solution would be to use a List instead of array in the first place.

List.remove(index)

If you have to use arrays, two calls to System.arraycopy will most likely be the fastest.

Foo[] result = new Foo[source.length - 1];
System.arraycopy(source, 0, result, 0, index);
if (source.length != index) {
    System.arraycopy(source, index + 1, result, index, source.length - index - 1);
}

(Arrays.asList is also a good candidate for working with arrays, but it doesn't seem to support remove.)

Answer 4

Use an ArrayList:

alist.remove(1); //removes the element at position 1

Answer 5

I hope you use the java collection / java commons collections!

With an java.util.ArrayList you can do things like the following:

yourArrayList.remove(someObject);

yourArrayList.add(someObject);

Answer 6

Copy your original array into another array, without the element to be removed.

A simplier way to do that is to use a List, Set... and use the remove() method.

Answer 7

Swap the item to be removed with the last item, if resizing the array down is not an interest.

Answer 8

okay, thx a lot now i use sth like this:

public static String[] removeElements(String[] input, String deleteMe) {
 if (input != null) {
  List<String> list = new ArrayList<String>(Arrays.asList(input));
  for (int i = 0; i < list.size(); i++) {
   if (list.get(i).equals(deleteMe)) {
    list.remove(i);
   }
  }
  return list.toArray(new String[0]);
 } else {
  return new String[0];
 }
}

Answer 9

You could use commons lang's ArrayUtils.

array = ArrayUtils.removeElement(array, element)

Javadocs

Answer 10

Wow, with about 10 answers here, nobody has come close to the right answer. I'm fairly stunned.

Do people just not know?

Anyway, this is the answer:

http://java.sun.com/j2se/1.4.2/docs/api/java/lang/System.html#arraycopy(java.lang.Object, int, java.lang.Object, int, int)

Look at the docs. You can use it to copy from and to the same array at a slightly different offset.

So to delete the an element:

public void removeElement(Object[] a, int del) {
    arraycopy(a,del+1,a,del,a.length-1-del);
}

Edit in response to comment:

It's not another good way, it's really the only acceptable way.

To allocate a collection (creates a new array), then delete an element (which the collection will do using arraycopy) then call toArray on it (creates a SECOND new array) for every delete brings us to the point where it's not an optimizing issue, it's criminally bad programming.

Suppose you had an array taking up, say, 100mb of ram. Now you want to iterate over it and delete 20 elements.

Give it a try...

I know you ASSUME that it's not going to be that big, or that if you were deleting that many at once you'd code it differently, but I've fixed an awful lot of code where someone made assumptions like that.

Answer 11

Your question isn't very clear. From your own answer, I can tell better what you are trying to do:

public static String[] removeElements(String[] input, String deleteMe) {
    List result = new LinkedList();

    for(String item : input)
        if(!deleteMe.equals(item))
            result.add(item);

    return result.toArray(input);
}

NB: This is untested. Error checking is left as an exercise to the reader (I'd throw IllegalArgumentException if either input or deleteMe is null; an empty list on null list input doesn't make sense. Removing null Strings from the array might make sense, but I'll leave that as an exercise too; currently, it will throw an NPE when it tries to call equals on deleteMe if deleteMe is null.)

Choices I made here:

I used a LinkedList. Iteration should be just as fast, and you avoid any resizes, or allocating too big of a list if you end up deleting lots of elements. You could use an ArrayList, and set the initial size to the length of input. It likely wouldn't make much of a difference.

Answer 12

You could use the ArrayUtils API to remove it in a "nice looking way". It implements many operations (remove, find, add, contains,etc) on Arrays.
Take a look. It has made my life simpler.

Answer 13

I think the question was asking for a solution without the use of the Collections API. One uses arrays either for low level details, where performance matters, or for a loosely coupled SOA integration. In the later, it is OK to convert them to Collections and pass them to the business logic as that.

For the low level performance stuff, it is usually already obfuscated by the quick-and-dirty imperative state-mingling by for loops, etc. In that case converting back and forth between Collections and arrays is cumbersome, unreadable, and even resource intensive.

By the way, TopCoder, anyone? Always those array parameters! So be prepared to be able to handle them when in the Arena.

Below is my interpretation of the problem, and a solution. It is different in functionality from both of the one given by Bill K and jelovirt. Also, it handles gracefully the case when the element is not in the array.

Hope that helps!

public char[] remove(char[] symbols, char c)
{
    for (int i = 0; i < symbols.length; i++)
    {
        if (symbols[i] == c)
        {
            char[] copy = new char[symbols.length-1];
            System.arraycopy(symbols, 0, copy, 0, i);
            System.arraycopy(symbols, i+1, copy, i, symbols.length-i-1);
            return copy;
        }
    }
    return symbols;
}

Answer 14

Some more pre-conditions are needed for the ones written by Bill K and dadinn

Object[] newArray = new Object[src.length - 1];
if (i > 0)
{
    System.arraycopy(src, 0, newArray, 0, i);
}
if (newArray.length > i)
{
 System.arraycopy(src, i + 1, newArray, i, newArray.length - i);
}    
return newArray;