List集合

List集合

集合介绍

        java中的集合类：是一种工具类，就像是容器，储存任意数量的具有共同属性的对象。（长度可变）

   java中的集合框架

List介绍

• 在List集合中允许出现重复的元素，所有元素以线性方式进行存储，可以通过索引来访问集合中指定的元素。List集合的元素的存储顺序和取出顺序一致。
• List中主要有ArrayList、LinkedList两个实现类；
  

ArrayList

        ArrayList是List接口的一个实现类，在ArrayList内部封装了一个数组对象.

• 初始长度缺省为10，该容量代表了数组的大小。

private static final int DEFAULT_CAPACITY = 10;

• ArrayList实现List，得到了List集合框架基础功能；

  int size();//获取集合中的元素个数
  boolean isEmpty();//判断集合是否为空
  boolean contains(Object o);//判断集合中是否存在指定的元素
  Object[] toArray();//把集合变成数组
  get(int index);//获取指定位置的元素
  set(int index, E element);//把指定索引位置的元素修改为指定的值，返回修改前的值
  Iterator iterator();//就是用来获取集合中每一个元素。
  void clear();//删除集合中的所有元素
  boolean add(E e);//向集合中添加一个元素	
  

• ArrayList实现RandomAccess，获得了快速随机访问存储元素的功能，RandomAccess是一个标记接口，没有任何方法；
• ArrayList实现Cloneable，得到了clone()方法，可以实现克隆功能；
• ArrayList实现Serializable，表示可以被序列化，通过序列化去传输，典型的应用就是hessian协议.

特点：

1.有序可重复
2.插入的元素可以为null
3.容量不固定，可以动态扩容
4.线程不安全

elementData[size] = e;
size = size + 1;

• 在单线程执行这两条代码时没有任何问题，但是当多线程环境下执行时，可能就会发生一个线程的值覆盖另一个线程添加的值。

源码分析

• 构造器

//ArrayList有参构造：容量大小
public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
        	//初始化数据：创建Object数组
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
        	//如果传递的初始容量小于0 ，抛出异常
          	throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);
        }
    }
//ArrayList有参构造：Java集合
public ArrayList(Collection<? extends E> c) {
		//将集合转换为数组：
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

• 添加
          ArrayList集合的内部使用一个数组来保存元素。用add(int index, E element)方法添加元素时，是把元素插入index指向的位置，先把该位置的元素以及后续元素都向后移一个位置，如果超出数组的容量，会创建更大的新数组。

//添加元素e
public boolean add(E e) {
    ensureCapacityInternal(size + 1);
    //将对应角标下的元素赋值为e：
    elementData[size++] = e;
    return true;
}
//得到最小扩容量
private void ensureCapacityInternal(int minCapacity) {
    //如果此时ArrayList是空数组,则将最小扩容大小设置为10：
    if (elementData == EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    //判断是否需要扩容：
    ensureExplicitCapacity(minCapacity);
}
//判断是否需要扩容
private void ensureExplicitCapacity(int minCapacity) {
    //操作数+1
    modCount++;
    //判断最小扩容容量-数组大小是否大于0：
    if (minCapacity - elementData.length > 0)
        //扩容：
        grow(minCapacity);
}
//ArrayList动态扩容的核心方法:
private void grow(int minCapacity) {
    //获取现有数组大小：
    int oldCapacity = elementData.length;
    //位运算，得到新的数组容量大小，为原有的1.5倍：
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    //如果新扩容的大小依旧小于传入的容量值，那么将传入的值设为新容器大小：
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;

    //如果新容器大小，大于ArrayList最大长度：
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        //计算出最大容量值：
        newCapacity = hugeCapacity(minCapacity);
    //数组复制：
    elementData = Arrays.copyOf(elementData, newCapacity);
}
// 计算ArrayList最大容量：
private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0)
        throw new OutOfMemoryError();
    //如果新的容量大于MAX_ARRAY_SIZE。将会调用hugeCapacity将int的最大值赋给newCapacity:
    return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
}

• 删除
          在删除元素时，会将被删除元素之后的元素都向前移一个位置以填补空位；

//针对于角标来进行删除，不需要去遍历整个集合，效率更高
//在ArrayList的移除index位置的元素
public E remove(int index) {
    //检查角标是否合法：不合法抛异常
    rangeCheck(index);
    //操作数+1：
    modCount++;
    //获取当前角标的value:
    E oldValue = elementData(index);
    //获取需要删除元素 到最后一个元素的长度，也就是删除元素后，后续元素移动的个数；
    int numMoved = size - index - 1;
    //如果移动元素个数大于0 ，也就是说删除的不是最后一个元素：
    if (numMoved > 0)
        // 将elementData数组index+1位置开始拷贝到elementData从index开始的空间
        System.arraycopy(elementData, index+1, elementData, index, numMoved);
    //size减1，并将最后一个元素置为null
    elementData[--size] = null;
    //返回被删除的元素：
    return oldValue;
}
//针对于对象来进行删除，需要遍历整个集合进行equals()方法比对，所以效率较低。
//在ArrayList的移除对象为O的元素，不返回被删除的元素：
public boolean remove(Object o) {
    //如果o==null，则遍历集合，判断哪个元素为null：
    if (o == null) {
        for (int index = 0; index < size; index++)
            if (elementData[index] == null) {
                //快速删除，和前面的remove（index）一样的逻辑
                fastRemove(index);
                return true;
            }
    } else {
        //同理：
        for (int index = 0; index < size; index++)
            if (o.equals(elementData[index])) {
                fastRemove(index);
                return true;
            }
    }
    return false;
}
//快速删除：
private void fastRemove(int index) {
    //操作数+1
    modCount++;
    //获取需要删除元素 到最后一个元素的长度，也就是删除元素后，后续元素移动的个数；
    int numMoved = size - index - 1;
    //如果移动元素个数大于0 ，也就是说删除的不是最后一个元素：
    if (numMoved > 0)
        // 将elementData数组index+1位置开始拷贝到elementData从index开始的空间
        System.arraycopy(elementData, index+1, elementData, index, numMoved);
    //size减1，并将最后一个元素置为null
    elementData[--size] = null;
}

• 因为增删元素会导致大量的内存操作，所以效率低，但ArrayList集合允许通过索引随机的访问元素，查询效率高。

LinkedList

         同样实现List接口的LinkedList与ArrayList不同，ArrayList是一个动态数组，而LinkedList是一个双向链表。链表中的每个元素都通过对象引用来记住它的前一个元素和后一个元素，从而将所有的元素彼此连接起来。

• LinkedList实现List，得到了List集合框架基础功能；

int size();//获取集合中的元素个数
boolean isEmpty();//判断集合是否为空
boolean contains(Object o);//判断集合中是否存在指定的元素
Object[] toArray();//把集合变成数组
get(int index);//获取指定位置的元素
set(int index, E element);//把指定索引位置的元素修改为指定的值，返回修改前的值
Iterator iterator();//就是用来获取集合中每一个元素。
void clear();//删除集合中的所有元素
boolean add(E e);//向集合中添加一个元素

• LinkedList实现Deque，Deque 是一个双向队列，也就是既可以先入先出，又可以先入后出，说简单点就是既可以在头部添加元素，也可以在尾部添加元素；

void addFirst(E e);//将指定元素插入此列表的开头
void addLast(E e);//将指定元素添加到列表的尾部
E removeFirst();//移除此列表的第一个元素
E removeLast();//移除此列表的最后一个元素
E getFirst();//返回此列表的第一个元素
E getLast();//返回此列表的最后一个元素

• LinkedList实现Cloneable，得到了clone()方法，可以实现克隆功能；
• LinkedList实现Serializable，表示可以被序列化，通过序列化去传输，典型的应用就是hessian协议。

特点

         由于是基于列表的，LinkedList的没有扩容方法！默认加入元素是尾部自动扩容！
        LinkedList是非线程安全的，只在单线程下适合使用。

源码分析

• 添加(一是直接添加一个元素，二是在指定角标下添加一个元素)

//添加元素：添加到最后一个结点；
public boolean add(E e) {
    linkLast(e);
    return true;
}

//last节点插入新元素：
void linkLast(E e) {
    //将尾结点赋值个体L:
    final java.util.LinkedList.Node<E> l = last;
    //创建新的结点，将新节点的前指针指向l:
    final java.util.LinkedList.Node<E> newNode = new java.util.LinkedList.Node<>(l, e, null);
    //新节点置为尾结点：
    last = newNode;
    //如果尾结点l为null：则是空集合新插入
    if (l == null)
        //头结点也置为 新节点：
        first = newNode;
    else
        //l节点的后指针指向新节点：
        l.next = newNode;
    //长度+1
    size++;
    //操作数+1
    modCount++;
}

//向对应角标添加元素：
public void add(int index, E element) {
    //检查传入的角标 是否正确：
    checkPositionIndex(index);
    //如果插入角标==集合长度，则插入到集合的最后面：
    if (index == size)
        linkLast(element);
    else
        //插入到对应角标的位置：获取此角标下的元素先
        linkBefore(element, node(index));
}

• 删除（一是通过角标删除元素，二是通过对象删除元素）

//删除对应角标的元素：
public E remove(int index) {
    checkElementIndex(index);
    //node()方法通过角标获取对应的元素，在后面介绍
    return unlink(node(index));
}

//删除LinkedList中的元素，可以删除为null的元素，逐个遍历LinkedList的元素，重复元素只删除第一个：
public boolean remove(Object o) {
    //如果删除元素为null：
    if (o == null) {
        for (java.util.LinkedList.Node<E> x = first; x != null; x = x.next) {
            if (x.item == null) {
                unlink(x);
                return true;
            }
        }
    } else {
        //如果删除元素不为null：
        for (java.util.LinkedList.Node<E> x = first; x != null; x = x.next) {
            if (o.equals(x.item)) {
                unlink(x);
                return true;
            }
        }
    }
    return false;
}

ArrayList和LinkedList的异同

• ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。
• 对于随机访问get和set，ArrayList绝对优于LinkedList，因为LinkedList要移动指针。
• 对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。（批量随机插入）