"Best" with respects to what?

The code above will be more efficient on a LinkedList than on an
ArrayList. As a general rule, when doing filtering operations
(conditional removing/keeping) on array-backed structures (ArrayList,
StringBuffer, etc.), it is more efficient, especially if the structure
is big, to copy those elements which are to be kept into a new
structure, and then to discard the old one, instead of perform multiple
deletions. Only if there would be a significant number (more than a
couple) of deletions, of course. Your mileage may vary, but it takes a
lot off the CPU and adds only little memory overhead.

DF.

First of all, an ArrayList takes linear time to remove a single
element, so repeated removal is a bad idea.

Either use a LinkedList, which can remove in constant time during
iteration, or first collect the elements in a HashSet and then remove
them at the end using Collection.removeAll(Collection). I suggest the
latter.

For ArrayList, the removeAll method takes time proportional to the
size of the list times the lookup time for the argument collection.
Using a HashSet as argument should minimize the time it takes.

If you only remove a few values, any collection will probably suffice.

I.e., either:

LinkedList tmpLinkedList = new LinkedList(myarraylist);
for(Iterator iter = tmpLinkedList.iterator(); iter.hasNext();) {
  if (test(iter.next)) { iter.remove(); }
}
myarraylist.clear();
myarraylist.addAll(tmpLinkedList);

or

HashSet toRemove = new HashSet();
for(Iterator iter = myarraylist.iterator(); iter.hasNext();) {
  Object elem = iter.next();
  if (test(elem)) { toRemove.add(elem); }
}
myarraylist.removeAll(toRemove);

This is assuming the test is complicated. If it's just equality
check, then you might be able to use removeAll directly.

For the above reasons, I'd say no.

In this simple case, where you only compare for equality (and even to
only a single value), it would suffice to do:
myarraylist.removeAll(Collections.singletonSet("abc"));
If you have more values, but still only do equality checks, just create
a collection and remove them all.
/L

From the point of view of coding simplicity, I think it is the best way.

If it becomes a performance bottleneck, investigate whether you should
switch to LinkedList or take other steps to reduce the cost.

Patricia

On Mon, 28 Jan 2008 14:46:35 -0800 (PST), Kevin
<happy_singapore@yahoo.com.sg> wrote, quoted or indirectly quoted
someone who said :

yes.

In article
<0fc7f374-c200-4032-a765-7b32bc3fed96@j20g2000hsi.googlegroups.com>,

Removing from ArrayList requires shifting elements so it can be slow.  
If an ArrayList is still the right tool, it may be faster in some cases
to build a new list based on what wouldn't be removed.  If you can't
rebuild, you can still get an improvement by going backwards through the
list.

I do not think so, as stated in the other replies. An Iterator moves
from the beginning of the ArrayList to the end, so that the complete
operation will terminate in O(n^2). However, as long as speed is not
an issue (or the lists are small), this approach is the cleanest one.

The fastest way to check all elements in an ArrayList, and remove
some of them is probably the following (assuming that the list is NOT
SORTED!)

ArrayList list = ...;
for (int i = list.size() - 1; i >= 0; i--) {
   if (elementNeedsToBeRemoved(list.get(i))) {
       list.set(i, list.get(list.size() -1 ));
       list.remove(list.size() - 1);
   }
}

This will work in O(n).

On Mon, 28 Jan 2008 14:46:35 -0800 (PST), Kevin
<happy_singapore@yahoo.com.sg> wrote, quoted or indirectly quoted
someone who said :

Another faster method if the lists are long is to copy leaving behind
the undesired elements.

This is the technique used in the SortedArrayList class.

See http://mindprod.com/products2.html#SORTED