Cfrgtkky

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.

The best choice would be to use a collection, but if that is out for some reason, use arraycopy. You can use it to copy from and to the same array at a slightly different offset.

For example:

public void removeElement(Object arr, int removedIdx) {

    System.arraycopy(arr, removedIdx + 1, arr, removedIdx, arr.length - 1 - removedIdx);

}

Edit in response to comment (tl;dr):

It's not another good way, it's really the only acceptable way--any tools that allow this functionality (like Java.ArrayList or the apache utils) will use this method under the covers. Also, you REALLY should be using ArrayList (or linked list if you delete from the middle a lot) so this shouldn't even be an issue unless you are doing it as homework.

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.

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

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.)

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;

}

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.

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;

You can not change the length of an array, but you can change the values the index holds by copying new values and store them to a existing index number.
1=mike , 2=jeff // 10 = george 11 goes to 1 overwriting mike .

Object array = new Object[10];

int count = -1;



public void myFunction(String string) {

    count++;

    if(count == array.length) { 

        count = 0;  // overwrite first

    }

    array[count] = string;    

}

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];

    }

}

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.

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

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);