基础：Java集合需要注意的 5 个问题

Java集合中的List、Set和Map作为Java集合食物链的顶级，可谓是各有千秋。本文将对于List、Set和Map之间的联系与区别进行介绍，以及这三者衍生出来的问题进行介绍（若无特地说明，jdk版本皆为1.8）：

addAll(Collection<? extends E> c)方法

public boolean addAll(Collection<? extends E> c) {
        boolean modified = false;
        for (E e : c)
            if (add(e))
                modified = true;
        return modified;
    }

public HashSet(Collection<? extends E> c) {
        map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
        addAll(c);
    }

public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        .......
    }

Set<Integer> set = new HashSet<>(list);
List<Integer> list = new ArrayList<>(set);

private transient HashMap<E,Object> map;

public boolean add(E e) {
    //如果return true，则表示不包含此元素  return map.put(e, PRESENT)==null;
}

public V put(K key, V value) {
    //倒数第二个参数为false，表示允许旧值替换
    //最后一个参数为true，表示HashMap不处于创建模式
  return putVal(hash(key), key, value, false, true);
}

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        //如果哈希表为空，调用resize()方法创建一个哈希表，并用n记录哈希表的长度
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        //如果指定参数hash（key的hashCode()值）在表中没有对应的桶，即没有碰撞
        //(n-1)&hash计算key将被放置的槽位
        //(n-1)&hash本质上是hash%n，只是位运算更快
        if ((p = tab[i = (n - 1) & hash]) == null)
            //如果没有碰撞，直接将键值对插入到map中即可
            tab[i] = newNode(hash, key, value, null);
        else { //如果桶中已经存在了元素
            Node<K,V> e; K k;
            //比较桶中的第一个元素（数组中的结点）的hash值、key是否相等
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                //如果相等，则将第一个元素p用e来记录
                e = p;
            else if (p instanceof TreeNode) //当前桶中无该键值对，且桶的结构为红黑树，则按照红黑树结构的规则插入元素
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else { //如果桶中无该键值对，且桶的结构为链表，则按照链表结构将元素插入到尾部
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) { //遍历到链表尾部
                        p.next = newNode(hash, key, value, null);
                        //检查链表长度是否达到阈值，达到则将该槽位的节点组织形式，转化为红黑树
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    //链表节点中的元素<key, value>与put操作控制的元素<key, value>相同时，不做重复操作，直接跳出程序
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            // 如果put操作控制的元素的key和hashCode，与已经插入的元素相等时，执行以下操作
            if (e != null) { // existing mapping for key
                // oldValue记录e的value
                V oldValue = e.value;
                // onlyIfAbsent为false，或旧值为null时，允许替换旧值，否则无需替换
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                //访问后回调
                afterNodeAccess(e);
                //返回旧值
                return oldValue;
            }
        }
        // 更新结构化修改信息
        ++modCount;
        // 键值对数目如果超过阈值时，执行resize()方法
        if (++size > threshold)
            resize();
        // 插入后回调
        afterNodeInsertion(evict);
        return null;
    }

public static void main(String[] args){
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(3);
        list.add(4);
        for(int i=0; i<list.size()-1; i++){
            if(list.get(i) == 3){
                list.remove(new Integer(3));
            }
        }
        System.out.println(list);
    }

for(int i=list.size()-1; i>=0; i--){
    if(list.get(i) == 3){
      list.remove(new Integer(3));
    }
}

for(Integer i : list){
    if(i == 3){
      list.remove(new Integer(3));
    }
}

Exception in thread "main" java.util.ConcurrentModificationException
  at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:901)
  at java.util.ArrayList$Itr.next(ArrayList.java:851)
  ...

private class Itr implements Iterator<E> {
    ......
    final void checkForComodification() {
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
  }
}

Iterator<Integer> i = list.iterator();
while(i.hasNext()){
Integer integer = i.next();
    if(integer == 3){
    i.remove();
    }
}