Java集合类学习（二） List集合

1 ArrayList和LinkedList

List集合的主要实现类有ArrayList和LinkedList。另外还包括栈和队列的实现类：Deque和Queue。
ArrayList的底层主要是数组实现，查找快增删慢。LinkedList的底层主要是双向链表实现，查找慢增删快。

1.1 ArrayList

• 在内存中分配连续的空间，实现了长度可变的数组
• 优点：遍历元素和随机访问元素的效率比较高，因为可以根据索引访问
• 缺点：添加和删除需大量移动元素效率低，按照内容查询效率低
  

1.2 LinkedList

• 采用双向链表存储方式。
• 缺点：遍历和随机访问元素效率低下，因为要从头节点（尾节点）向后（向前）遍历
• 优点：插入、删除元素效率比较高
  

1.3 何时使用LinkedList与ArrayList

• 根据使用场合而定
• 大量的根据索引查询的操作，大量的遍历操作（按照索引0–n-1逐个查询一般），建议使用ArrayList
• 如果存在较多的添加、删除操作，建议使用LinkedList

2 List接口方法摘要

返回值类型	方法
boolean	add(E e)向列表的尾部添加指定的元素（可选操作）。
void	add(int index, E element) 在列表的指定位置插入指定元素（可选操作）。
boolean	addAll(Collection<? extends E> c) 添加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭代器返回这些元素的顺序（可选操作）。
boolean	addAll(int index, Collection<? extends E> c) 将指定 collection 中的所有元素都插入到列表中的指定位置（可选操作）。
void	clear() 从列表中移除所有元素（可选操作）。
boolean	contains(Object o) 如果列表包含指定的元素，则返回 true。
boolean	containsAll(Collection<?> c) 如果列表包含指定 collection 的所有元素，则返回 true。
E	get(int index) 返回列表中指定位置的元素。
boolean	isEmpty() 如果列表不包含元素，则返回 true。
Iterator<E>	iterator() 返回按适当顺序在列表的元素上进行迭代的迭代器。
E	remove(int index) 移除列表中指定位置的元素（可选操作）。
boolean	remove(Object o) 从此列表中移除第一次出现的指定元素（如果存在）（可选操作）。
boolean	removeAll(Collection<?> c) 从列表中移除指定 collection 中包含的其所有元素（可选操作）。
boolean	retainAll(Collection<?> c) 仅在列表中保留指定 collection 中所包含的元素（可选操作）。
E	set(int index, E element) 用指定元素替换列表中指定位置的元素（可选操作）。
int	size() 返回列表中的元素数。

3 ArrayList源码分析

3.1 ArrayList的基本属性

public class ArrayList<E> extends AbstractList<E> implements List<E>, 
								RandomAccess, Cloneable, Serializable{//随机存取、克隆、序列化 均为空接口，目的是为了判断
       private static final int DEFAULT_CAPACITY = 10;//数组的默认长度
       private static final Object[] EMPTY_ELEMENTDATA = {};//空数组
       private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};//默认容量空数组
       transient Object[] elementData;//Object数组
       private int size;//集合大小，默认值为0
}

//DEFAULTCAPACITY_EMPTY_ELEMENTDATA的用处：在调用无参构造方法时赋值给elementData数组
public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

//EMPTY_ELEMENTDATA的用处：在指定数组长度为0时赋值给elementData数组
public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }

为啥要写的这么弯弯绕绕呢？如果一个应用中有很多ArrayList空实例的话，就会有很多的空数组，这是为了优化性能，使所有ArrayList空实例都指向同一个空数组。

3.2 ArrayList的扩容

既然ArrayList是一个长度可变的数组，那么他就应该有相应的长度增长也就是扩容机制。

 //添加操作
 public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // 确保空间足够
        elementData[size++] = e;//给数组的第size位赋值后size+1（先取值，后加加）
        return true;
 }
 private void ensureCapacityInternal(int minCapacity) {
       ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
 }
 //计算容量
 private static int calculateCapacity(Object[] elementData, int minCapacity) {
     if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {//如果数组是初始化时的空数组
         return Math.max(DEFAULT_CAPACITY, minCapacity);//返回默认容量和传过来的最小容量中的最大值
     }
     return minCapacity;//否则返回传过来的最小容量
 }
 //确保容量够用
 private void ensureExplicitCapacity(int minCapacity) {
     modCount++;
	 //如果数组长度小于最小容量，即容量不够了，则扩容
     if (minCapacity - elementData.length > 0)
         grow(minCapacity);
 }
 private void grow(int minCapacity) {
     // overflow-conscious code
     int oldCapacity = elementData.length;//原有容量
     int newCapacity = oldCapacity + (oldCapacity >> 1);//新容量=旧容量+旧容量右移一位（即旧容量的50%）
     if (newCapacity - minCapacity < 0)//如果扩容后的容量还是小于最小容量
         newCapacity = minCapacity;//直接把最小容量赋值给新容量
     if (newCapacity - MAX_ARRAY_SIZE > 0)//容量有上限，即int能表示的最大值-8，超过则抛异常
         newCapacity = hugeCapacity(minCapacity);
     elementData = Arrays.copyOf(elementData, newCapacity);//指向扩容后的新数组
 }

4 LinkedList源码分析

4.1 LinkedList的基本属性和方法

public class LinkedList<E> extends AbstractSequentialList<E>
    					   implements List<E>, Deque<E>, Cloneable, java.io.Serializable{//除了实现了List接口，还实现了Deque接口，说明LinkedList还可以当队列和zhan使用
    transient int size = 0;//节点的数量
    transient Node<E> first; //指向第一个节点
    transient Node<E> last; //指向最后一个节点
    public LinkedList() {  }
}
//静态私有内部类
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;
    }
}
//添加方法
public boolean add(E e) {
        linkLast(e);
        return true;
}
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++;
}