Whats the replacement of For-Each loop for filtering?

Question

Though for-each loop has many advantages but the problem is ,it doesn't work when you want to Filter(Filtering means removing element from List) a List,Can you please any replacement as even traversing through Index is not a good option..

Answer 1

What do you mean by "filtering"? Removing certain elements from a list? If so, you can use an iterator:

for(Iterator<MyElement> it = list.iterator(); it.hasNext(); ) {
    MyElement element = it.next();
    if (some condition) {
      it.remove();
    }
}

Update (based on comments):

Consider the following example to illustrate how iterator works. Let's say we have a list that contains 'A's and 'B's:

A A B B A

We want to remove all those pesky Bs. So, using the above loop, the code will work as follows:

1. hasNext()? Yes. next(). element points to 1st A.
2. hasNext()? Yes. next(). element points to 2nd A.
3. hasNext()? Yes. next(). element points to 1st B. remove(). iterator counter does NOT change, it still points to a place where B was (technically that's not entirely correct but logically that's how it works). If you were to call remove() again now, you'd get an exception (because list element is no longer there).
4. hasNext()? Yes. next(). element points to 2nd B. The rest is the same as #3
5. hasNext()? Yes. next(). element points to 3rd A.
6. hasNext()? No, we're done. List now has 3 elements.

Update #2: remove() operation is indeed optional on iterator - but only because it is optional on an underlying collection. The bottom line here is - if your collection supports it (and all collections in Java Collection Framework do), so will the iterator. If your collection doesn't support it, you're out of luck anyway.

Answer 2

ChssPly76's answer is the right approach here - but I'm intrigued as to your thinking behind "traversing through index is not a good option". In many cases - the common case in particular being that of an ArrayList - it's extremely efficient. (In fact, in the arraylist case, I believe that repeated calls to get(i++) are marginally faster than using an Iterator, though nowhere near enough to sacrifice readability).

Broadly speaking, if the object in question implements java.util.RandomAccess, then accessing sequential elements via an index should be roughly the same speed as using an Iterator. If it doesn't (e.g. LinkedList would be a good counterexample) then you're right; but don't dismiss the option out of hand.

Answer 3

I have had success using the

filter(java.util.Collection collection, Predicate predicate)

method of CollectionUtils in commons collections.

http://commons.apache.org/collections/api-2.1.1/org/apache/commons/collections/CollectionUtils.html#filter%28java.util.Collection,%20org.apache.commons.collections.Predicate)

Answer 4

If you, like me, don't like modifying a collection while iterating through it's elements or if the iterator just doesn't provide an implementation for remove, you can use a temporary collection to just collect the elements you want to delete. Yes, yes, its less efficient compared to modifying the iterator, but to me it's clearer to understand whats happening:

List<Object> data = getListFromSomewhere();
List<Object> filter = new ArrayList<Object>();

// create Filter
for (Object item: data) {
  if (throwAway(item)) {
    filter.add(item);
  }
}

// use Filter
for (Object item:filter) {
  data.remove(item);
}

filter.clear();
filter = null;