List : ArrayList、LinkedList、Vector

一.介绍

1.ArrayList源码分析

1. ArrayList的继承与接口实现

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

2. ArrayList构造方法：

	/**
     * 有参构造方法：指定初始长度
     */
    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);
        }
    }

    /**
     * 无参构造方法：默认初始长度为10
     */
    public ArrayList() {
     
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

3. 默认初始长度:

	/**
     * Default initial capacity.
     */
    private static final int DEFAULT_CAPACITY = 10;

4. ArrayList扩容机制:

	/**
     * 当所需长度大于原来的数组长度，创建一个新数组，长度为原理数组长度的1.5倍
     * 当所需长度小于原来的数组长度，则把要添加的元素直接添加到最后一位。
     */
    private void grow(int minCapacity) {
     
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

5. 总结：

• ArrayList是实现List接口的，底层采用数组实现。

• ArrayList 实现了Cloneable接口，即覆盖了函数clone()，能被克隆。

• ArrayList 实现java.io.Serializable接口，这意味着ArrayList支持序列化，能通过序列化去传输。

优点 ： 底层数据结构是数组，查询快，增删慢。
缺点 ： 线程不安全，效率高。

2. LinkedList

1. Linked的继承与接口实现：

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable

2. LinkedList构造方法：

	/**
     * 无参构造方法
     */
    public LinkedList() {
     
    }

    /**
     * 有参构造方法：包含一个集合
     */
    public LinkedList(Collection<? extends E> c) {
     
        this();
        addAll(c);
    }

3. 总结：

• LinkedList继承AbstractSequentialList，AbstractSequentialList 实现了get(int index)、set(int index, E element)、add(int index, E element) 和 remove(int index)这些函数。这些接口都是随机访问List的。

• LinkedList 实现 List 接口，能对它进行队列操作。

• LinkedList 实现 Deque 接口，即能将LinkedList当作双端队列使用。

• LinkedList 实现了Cloneable接口，即覆盖了函数clone()，能克隆。

• LinkedList 实现java.io.Serializable接口，这意味着LinkedList支持序列化，能通过序列化去传输。

优点 ： 底层数据结构是双向链表，查询慢，增删快。
缺点 ： 线程不安全，效率高。

3.Vector

1. Vector的构造方法

public Vector(int initialCapacity, int capacityIncrement) {
     
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        this.elementData = new Object[initialCapacity];
        this.capacityIncrement = capacityIncrement;
    }


    public Vector(int initialCapacity) {
     
        this(initialCapacity, 0);
    }

3. Vector方法

	// 同步方法
	public synchronized void copyInto(Object[] anArray) {
     
        System.arraycopy(elementData, 0, anArray, 0, elementCount);
    }

• Vector是实现List接口的，底层采用数组实现。

• Vector实现了Cloneable接口，即覆盖了函数clone()，能被克隆。

• Vector实现java.io.Serializable接口，这意味着Vectort支持序列化，能通过序列化去传输。

• Vector的方法都是同步的，线程安全。

优点: 底层数据结构是数组，查询快，增删慢。
缺点: 线程安全，效率低