//
// Different methods to deal with ConcurrentModificationException
//
// We will delete even numbers from a list of random numbers.
//
// http://docs.oracle.com/javase/tutorial/collections/interfaces/list.html
//

import java.util.ArrayList;
import java.util.Random;
import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.lang.IndexOutOfBoundsException;


class Store{
	private ArrayList<Integer> work;
	private ArrayList<Integer> copy;
	private int size;

	public Store(int size) {
		Random randomGenerator = new Random();
		int index;

		this.size = size;
		work = new ArrayList<Integer>();
		copy = new ArrayList<Integer>();

		for( index=0; index<size; index++ )
			work.add(randomGenerator.nextInt(100));

	}

	public void copy() {
		copy.clear();
		for (Integer i : work){
			copy.add(i);
		}
	}

	public int find_even() {
		int even=0;
		int odd=0;
		for (Integer i : copy){
			if ( 0 == i%2 )
				even++;
			else
				odd++;
		}
		System.out.println("even: " + even + "| odd: " + odd);
		return even;
	}
	public void print(boolean printcopy) {
		ArrayList<Integer>list=(printcopy?copy:work);
		String header=(printcopy?"copy":"work");

		System.out.println(header);
		for (Integer i : list){
			System.out.println(i);
		}
	}

	public void remove_even_iteration() throws ConcurrentModificationException{
		//
		// ERROR/FAIL
		// This will trow java.util.ConcurrentModificationException
		//
		for (Integer i : copy){
			if ( 0 == i%2 )
				copy.remove(i);
		}
	}
	
	public void remove_even_iteration_aux() {
		//
		// This will create "to_remove" auxiliar ArrayList,
		// so we don't modify original list while iterating original list
		//
		// Simple, but slow
		//
		ArrayList<Integer> to_remove = new ArrayList<Integer>();
		for (Integer i : copy){
			if ( 0 == i%2 )
				to_remove.add(i);
		}
		for (Integer i : to_remove){
			copy.remove(i);
		}
	}
	@SuppressWarnings("unchecked")
	public void remove_even_clone() {
		//
		// Iterate on a cloned list.
		// Even simpler, but uses too much resources (x2)
		// Compiler complains about "unchecked cast"
		//

		for (Integer i : (ArrayList<Integer>)copy.clone()){
			if ( 0 == i%2 )
				copy.remove(i);
		}
	}
	
	public void remove_even_iterator() {
		//
		// Using "Iterator" differs from "for(:)", and it's safe
		//
		// In fact, it's the "right" way to do it.
		//
		Iterator<Integer> iter = copy.iterator();

		while (iter.hasNext()) {
			if ( 0 == iter.next().intValue()%2 )
				iter.remove();
		}
	}
	
	public void remove_even_for_index() throws IndexOutOfBoundsException {
		//
		// ERROR/FAIL
		// Use incremental index
		//
		// This will trow java.lang.IndexOutOfBoundsException
		// since when deleting an item, the size of the array
		// decreases.
		//
		int index=0;
		Integer i;

		for( index=0; index<size; index++ )
		{
			i = copy.get(index);
			if ( 0 == i%2 )
				copy.remove(i);
		}
	}
	
	
	public void remove_even_for_index_2() {
		//
		// ERROR/FAIL: elements after deleted ones are not evaluated
		// Use incremental index. Evaluate size on every loop
		//
		int index=0;
		Integer i;

		for( index=0; index<copy.size(); index++ )
		{
			i = copy.get(index);
			if ( 0 == i%2 )
				copy.remove(i);
		}
	}
	
	public void remove_even_for_index_cond() {
		//
		// Use incremental index, don't increment index on deletions
		// Decrease size of ArrayList instead.
		//
		//
		int index=0;
		int s=size;
		Integer i;

		for( index=0; index<s; )
		{
			i = copy.get(index);
			if ( 0 == i%2 )
			{
				copy.remove(i);
				s--;
			}
			else
				index++;
		}
	}

	
	public void remove_even_for_index_rev() {
		//
		// Use reverse index
		//
		int index=0;
		Integer i;

		for( index=size-1; index>0; index--)
		{
			i = copy.get(index);
			if ( 0 == i%2 )
			{
				copy.remove(i);
			}
		}
	}
}


public class collection {
    public static void main (String args[]) {

		Store store = new Store(1000);


		System.out.println("#### TRYING: remove even number by iterating");
		store.copy();
		store.find_even();
		try {
			store.remove_even_iteration();
		}
		catch ( ConcurrentModificationException e ) {
			System.out.println("# ConcurrentModificationException");
		}
		store.find_even();

		System.out.println("#### TRYING: remove even number by iterating with auxiliar list");
		store.copy();
		store.find_even();
		store.remove_even_iteration_aux();
		store.find_even();

		System.out.println("#### TRYING: remove even number by iterating clone list");
		store.copy();
		store.find_even();
		store.remove_even_clone();
		store.find_even();

		System.out.println("#### TRYING: remove even number by using iterator");
		store.copy();
		store.find_even();
		store.remove_even_iterator();
		store.find_even();

		System.out.println("#### TRYING: remove even number by incremental index");
		store.copy();
		store.find_even();
		try {
			store.remove_even_for_index();
		}
		catch ( IndexOutOfBoundsException e ) {
			System.out.println("# IndexOutOfBoundsException");
		}
		store.find_even();

		System.out.println("#### TRYING: remove even number by incremental index size()");
		store.copy();
		store.find_even();
		store.remove_even_for_index_2();
		store.find_even();

		System.out.println("#### TRYING: remove even number by incremental index conditional");
		store.copy();
		store.find_even();
		store.remove_even_for_index_cond();
		store.find_even();

		System.out.println("#### TRYING: remove even number by reverse index");
		store.copy();
		store.find_even();
		store.remove_even_for_index_rev();
		store.find_even();


	}
}