Remove even numbers from an ArrayList

Question

I have to create a method which has an ArrayList; I need to remove even numbers from this ArrayList. I have written code for that but there is a logical error which I couldn't identify.

Here is my code:

static void sortList(){

   List <Integer> number=new ArrayList <Integer>();

   number.add(11);
   number.add(45);
   number.add(12);
   number.add(32);
   number.add(36);

   System.out.println("Unsorted List: "+number);

   for (int i=0;i<number.size();i++){      
       int even=number.get(i)%2;       
        if (even==0){
            System.out.println("This is Even Number:"+ number.get(i));
            number.remove(i);
        }    
    }

    Collections.sort(number);
    System.out.println("Sorted List: "+number);

 }

The output of the code is:

Unsorted List: [11, 45, 12, 32, 36]
This is Even Number:12
This is Even Number:36
Sorted List: [11, 32, 45]

I am wondering that why 32 is not caught as an Even number as it is an even number, I tested then by using different even numbers at same position but the result is same. Why at index(3) its happening that any even number couldnt be catch. I am really wondering why. So please any one can help me out for this and is there any other better way to implement this solution.

Thanks

Answer 1

When you remove something from the list, the indexes of everything after that changes!

Specifically, in your implementation 32 is not removed as it comes directly after another even number.

I would use an Iterator to walk over the list, and the remove operation on that iterator instead, something like this:

for(Iterator i = number.iterator(); i.hasNext(); ) {
    if (isEven(i.next()) {
        i.remove();
    }
}

Answer 2

If you remove an entry from the list whilst looping over it, you'll have to adjust your loop index. Don't forget, removing the element reduces the length of the list by one, and effectively "shuffles back" the index of all elements after it.

Answer 3

The problem (as others have mentioned) is that you are modifying the list while you are traversing it. Try adding a "i--;" line inside your "if (even==0)" block. Like this:

for (int i=0;i<number.size();i++){
    int even=number.get(i)%2;

    if (even==0){
        System.out.println("This is Even Number:"+ number.get(i));
        number.remove(i);

        // Add this:
        i--;
    }
}

Answer 4

Both answers about list indices changing are correct. However, also be aware that removing an item from an ArrayList is slow because it has to actually shuffle all of the following entries down. Instead, I recommend creating a new list containing only the even numbers, and then just throwing away the old list. If you want to use the Iterator-based remove code in the other answer, it will work fine for small results as is, and for larger data sets if you use LinkedList. (I believe that is the name; my Java is admittedly slightly rusty.)

Answer 5

Use an Iterator. It has an remove() method which you need.

List<Integer> numbers = new ArrayList<Integer>();

numbers.add(11);
numbers.add(45);
numbers.add(12);
numbers.add(32);
numbers.add(36);

System.out.println("Unsorted List: " + numbers);

for (Iterator<Integer> iterator = numbers.iterator(); iterator.hasNext();) {
    Integer number = iterator.next();
    if (number % 2 == 0) {
        System.out.println("This is Even Number: " + number);
        iterator.remove();
    }

}

Collections.sort(numbers);
System.out.println("Sorted List: " + numbers);

Answer 6

Here's another nifty way of filtering for odd elements. Instead of looping through the collection manually, offload the work to Apache Commons Collections

 // apply a filter to the collection
 CollectionUtils.filter(numbers, new Predicate() {
     public boolean evaluate(Object o) {
         if ((((Integer) o) % 2) == 0) { 
             return false;  // even items don't match the filter
         }
         return true;  // odd items match the filter
     }
 });

It's debatable whether this is actually easier to read and understand, but it's more fun. If a certain kind of Predicate is used frequently, it can be refactored out into a static constant and reused all over the place. This could turn the usage of it into something a lot cleaner:

CollectionUtils.filter(numberList, ODD_PREDICATE);