Getting rid of ConcurrentModificationException

Iterator iterator = collection.iterator(); while (iterator.hasNext()) { Object element = iterator.next(); if (iDontLikeThisElement(element)) { iterator.remove(); } } 

 for (E element : collection) { if (iDonLikeThisElement(element)) { collection.remove(element); // ! ConcurrentModificationException! } } 

 Set<String> set = Collections.newSetFromMap(new ConcurrentHashMap<>()); 

1. Usually we do not need multithreading at all.
2. Null is not supported as elements, neither keys, nor values. Oh well, to be honest.
3. The order of the elements is not defined and can change - this is much worse. Those. if we run through the elements and do some calculation with loss of accuracy, then we may face unpleasant surprises and different results on the same data sets, which, say, is not always good. There are also tasks where it is desirable to preserve the original data order. Well, here such things also have a place to be:

 set.add("aaa"); set.add("bbb"); for (String s : set) { set.add("ddd"); System.out.println(s); } 

 set.add("aaa"); set.add("bbb"); for (String s : set) { set.add("ccc"); System.out.println(s); } 

1. Within one thread, you can add and remove items at any time without any exceptions. And of course for the constant time.
2. You can store nulls if you suddenly want to.
3. Items are bypassed in the order in which they were added.

1. Removing an element we will not reset the link to the next one, i.e. if the iterator is on this element, then it can go further.
2. At the end of the list we place a fake element that turns into a real one when something is added to the list. Those. even having reached the end of the list, the iterator does not rest on null and can continue to work if a new item appears in the collection. Further in the code this fake element is called placeholder.

1. In the beginning we have the elements A, B, C, D.
2. Then elements C and D are deleted.
3. A new element E is added.

 import java.util.AbstractSet; import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.NoSuchElementException; public class LinkedSet<E> extends AbstractSet<E> { private static class LinkedElement<E> { E value; boolean exists; LinkedElement<E> prev; LinkedElement<E> next; } private Map<E, LinkedElement<E>> map = new HashMap<>(); private LinkedElement<E> placeholder = new LinkedElement<>(); private LinkedElement<E> head = placeholder; @Override public boolean isEmpty() { return head == placeholder; } @Override public int size() { return map.size(); } @Override public boolean contains(Object o) { return map.containsKey(o); } //     , ,  } 

  @Override public boolean add(E e) { LinkedElement<E> element = map.putIfAbsent(e, placeholder); if (element != null) { return false; } element = placeholder; element.exists = true; element.value = e; placeholder = new LinkedElement<>(); placeholder.prev = element; element.next = placeholder; return true; } 

  @Override public boolean remove(Object o) { LinkedElement<E> removedElement = map.remove(o); if (removedElement == null) { return false; } removeElementFromLinkedList(removedElement); return true; } private void removeElementFromLinkedList(LinkedElement<E> element) { element.exists = false; element.value = null; element.next.prev = element.prev; if (element.prev != null) { element.prev.next = element.next; element.prev = null; } else { head = element.next; } } 

  @Override public Iterator<E> iterator() { return new ElementIterator(); } private class ElementIterator implements Iterator<E> { LinkedElement<E> next = head; LinkedElement<E> current = null; LinkedElement<E> findNext() { LinkedElement<E> n = next; while (!n.exists && n.next != null) { next = n = n.next; } return n; } @Override public boolean hasNext() { return findNext().exists; } @Override public E next() { LinkedElement<E> n = findNext(); if (!n.exists) { throw new NoSuchElementException(); } current = n; next = n.next; return n.value; } @Override public void remove() { if (current == null) { throw new IllegalStateException(); } if (map.remove(current.value, current)) { removeElementFromLinkedList(current); } else { throw new NoSuchElementException(); } } } 

 Set<Integer> set = new LinkedSet<>(); // ... put some numbers set.stream().filter(v -> v % 2 == 0).forEach(set::remove);