List 源码解析

List

ArrayList和LinkedList都继承自abstractList 都是线程不安全的。

• abstractList 提供checkForComodification方法（next，add，remove方法中都有调用此方法），在单线程中，遍历的时候删除List（for循环和增强for循环都不是正确做法，迭代器遍历才是正确的，博客后面有例子声明）。当两个线程有冲突时，（当一个线程使用迭代器遍历的时候，另一线程add，remove时，都会改变modcount值。）会抛出ConcurrentModificationException异常。

final void checkForComodification() {
       if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
        }

ArrayList

• 基于数组实现的， 查找较快
  
  • 既然是基于数组实现的，就需要考虑扩容的问题。每次add的时候去判断当前数组+1 是否超过数组范围，如果超过，自动扩容1.5倍+1，并采用数组复制，复制原来的数据

源码解析:

• remove方法，也采用数组复制，复制删除的元素后面的全部元素，到要删除的元素位置

LinkedList

• 基于链表实现，双向循环链表，插入删除较快

源码解析

• 数据结构
  
  • list类里面有瞬时变量 记录 firstNode，lastNode，size，modCount
  • 元素Node E泛型的value值，前后节点指针。由此可见双向循环链表

private static class Node<E> {
        E item;
        Node<E> next;
        Node<E> prev;

        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }

• add方法
  
  • 在链表的尾部加，构造方法创建新的向前指针指向原来的la

void linkLast(E e) {
        final Node<E> l = last;
        final Node<E> newNode = new Node<>(l, e, null);
        last = newNode;
        if (l == null)
            first = newNode;  //新建第一个节点的
        else
            l.next = newNode;
        size++;
        modCount++;
    }

• remove 方法 节点前后置为null， 置前/置后 同时判断节点前后是不是节点头或节点尾。

  E unlink(Node<E> x) {
        // assert x != null;
        final E element = x.item;
        final Node<E> next = x.next;
        final Node<E> prev = x.prev;

        if (prev == null) {
            first = next;
        } else {
            prev.next = next;
            x.prev = null;
        }

        if (next == null) {
            last = prev;
        } else {
            next.prev = prev;
            x.next = null;
        }

        x.item = null;
        size--;
        modCount++;
        return element;
    }

---

List遍历循环删除几种方式

以下都是单线程，多线程无论哪种方式都会抛出异常
1. 采用for循环遍历删除，结果并不准确。

public class ListRemoveTest {

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

输出结果：最后结果=[1, 2, 2, 3, 4]

因为每次循环时，list的size不断改变减小，但i值不断增加，就会越过一些元素，所以是由问题的。如下是正确的。

for (int i = 0; i < list.size();) {
                System.out.println("=" + list.toString());
                System.out.println(i+"i=");
                if (2 == list.get(i)) {
                    list.remove(i);//删除一个元素时，i值不改变，因为list的remove方法会将后面的数组复制、移动到删除元素的位置
                }else{
                    i++;
                }
            }

1. 采用增强for循环，会抛出异常

for (Integer value : list) {
       if (2 == value) {
                    list.remove(value);
            }
                System.out.println(value);
            }

输出结果：java.util.ConcurrentModificationException
Java中的For each实际上使用的是iterator进行处理的。而iterator是不允许集合在iterator使用期间删除的。所以导致了iterator抛出了ConcurrentModificationException 。

3.在遍历List过程中删除元素的正确做法

Iterator<Integer> it = list.iterator();
    while (it.hasNext()) {
            Integer value = it.next();
            if (2 == value) {
                it.remove();
            }
            System.out.println(value);
        }

最后结果=[1, 3, 4]