Callback<ItemMessage> deleteCallback = new Callback<ItemMessage>() {
        @Override
        public void success(ItemMessage item, Response response) {
          //wrong 
          //This foreach loop creates an Iterator object in the background.
          for(ItemMessage i:itemMessages){
             if(i.getItemId() == currentItemId){
                 itemMessages.remove(i);
             }
          }

          //Right
          for(int i = 0; i<itemMessages.size(); i++){
              if(itemMessages.get(i).getItemId() == currentItemId){
                  itemMessages.remove(i);
              }
          }


         //wrong
         ListIterator<ItemMessage> itWrong = itemMessages.iterator();
         while(itWrong.hasNext()){
          ItemMessage value = itWrong.next();
           if(value.getItemId() == currentItemId){
               itemMessages.remove(value);
           }
         }

         //right
         ListIterator<ItemMessage> it = itemMessages.listIterator();
         while (it.hasNext()){
          ItemMessage value = it.next();
          if(value.getItemId() == currentItemId){
              it.remove();// This wil remove the element that we just got using the next() method
              it.add(new ItemMessage());// THis inserts the element immediately before the next call to next()
          }
      }

      adapter.notifyDataSetChanged();
      }
      @Override
      public void failure(RetrofitError error) {
          //handle the error
      }
  }

    //A counter for changes to the list.
    protected transient int modCount;

    java.util.ArrayList
    @Override public boolean remove(Object object) {
        Object[] a = array;
        int s = size;
        if (object != null) {
            for (int i = 0; i < s; i++) {
                if (object.equals(a[i])) {
                    System.arraycopy(a, i + 1, a, i, --s - i);
                    a[s] = null;  // Prevent memory leak
                    size = s;
                    modCount++;
                    return true;
                }
            }
        } else {
            for (int i = 0; i < s; i++) {
                if (a[i] == null) {
                    System.arraycopy(a, i + 1, a, i, --s - i);
                    a[s] = null;  // Prevent memory leak
                    size = s;
                    modCount++;
                    return true;
                }
            }
        }
        return false;
    }

    //只是修改了modCount，因此modCount将与expectedModCount的值不一致 



    //而ArrayList的私有类 ArrayListIterator的remove是这样实现的

    //保证了modCount和expectedModCount的值的一致性，避免抛出ConcurrentModificationException异常

        private class ArrayListIterator implements Iterator<E> {
        //Number of elements remaining in this iteration
        private int remaining = size;

        //Index of element that remove() would remove, or -1 if no such elt
        private int removalIndex = -1;

        //The expected modCount value 
        private int expectedModCount = modCount;

        public void remove() {
            Object[] a = array;
            int removalIdx = removalIndex;
            if (modCount != expectedModCount) {
                throw new ConcurrentModificationException();
            }
            if (removalIdx < 0) {
                throw new IllegalStateException();
            }
            System.arraycopy(a, removalIdx + 1, a, removalIdx, remaining);
            a[--size] = null;  // Prevent memory leak
            removalIndex = -1;
            expectedModCount = ++modCount;
        }

 Iterator<String> iterator = list.iterator();
  synchronized(synObject) {
      while(iterator.hasNext()) {
          String str = iterator.next();
          if(del.contains(str)) {
               iterator.remove();
          }
      }
  }

  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  import java.util.concurrent.ConcurrentHashMap;
  import java.util.concurrent.CopyOnWriteArrayList;

  public class ThreadSafeIteratorExample {

      public static void main(String[] args) {

              List<String> myList = new CopyOnWriteArrayList<String>();

              myList.add("1");
          myList.add("2");
              myList.add("3");
          myList.add("4");
          myList.add("5");

          Iterator<String> it = myList.iterator();
               while(it.hasNext()){
                   String value = it.next();
                   System.out.println("List Value:"+value);
              if(value.equals("3")){
                    myList.remove("4");
                    myList.add("6");
                   myList.add("7");
              }
          }
          System.out.println("List Size:"+myList.size());

          Map<String,String> myMap =
             new ConcurrentHashMap<String,String>();
          myMap.put("1", "1");
          myMap.put("2", "2");
          myMap.put("3", "3");

          Iterator<String> it1 = myMap.keySet().iterator();
          while(it1.hasNext()){
              String key = it1.next();
              System.out.println("Map Value:"+myMap.get(key));
              if(key.equals("1")){
                  myMap.remove("3");
                  myMap.put("4", "4");
                  myMap.put("5", "5");
              }
          }

           System.out.println("Map Size:"+myMap.size());
      }
  }

 List Value:1
  List Value:2
  List Value:3
  List Value:4
  List Value:5

  List Size:6

  Map Value:1
  Map Value:null
  Map Value:4
  Map Value:2

  Map Size:4