ArrayList LinkedList Vector 集合区别

1、ArrayList特点详解

存储结构：数组存储，

线程安全：非安全线程

查询速度：速度快

更新删除：速度慢

初始化：10个数组空间，后续以5个增加

/**
 * 1、数据结构，数组存储类型
 * 2、初始化：10个结构，后续以5个增加
 * 3、速度：set，get，add，较快，。remove，add，慢[后面数据移位]
 * 4、线程安全：不是安全线程
 */

private void testArrayList() {
    //场景一：
    ArrayList arrayList = new ArrayList();
    arrayList.add(1);
    arrayList.add(2);
    arrayList.add(3);
    arrayList.add(4);
    //源码：
    //初始定义一个常量为10，默认数据elementData，add时创建
    /**
     * Default initial capacity.
     * private static final int DEFAULT_CAPACITY = 10;
     * //调取add方法，创建一个elementData大小的数组
     * public boolean add(E e) {
     *      ensureCapacityInternal(size + 1);  // Increments modCount!!
     *      elementData[size++] = e;
     *      return true;
     * }*/

    /**
     * The array buffer into which the elements of the ArrayList are stored.
     * The capacity of the ArrayList is the length of this array buffer. Any
     * empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
     * will be expanded to DEFAULT_CAPACITY when the first element is added.
     */
    //transient Object[] elementData;


    /**
     * 场景二：
     * add，remove，数组位后移动，速度较慢
     */
    Object oldValue = arrayList.remove(1);
   /* 源码：
   public E remove(int index) {
        rangeCheck(index);//校验数据越界
        modCount++;
        E oldValue = elementData(index);//返回被删除数据
        int numMoved = size - index - 1;//需要被移动数组
        if (numMoved > 0)               //如果不是最后一位
            System.arraycopy(elementData, index+1, elementData, index,
                    numMoved);          //进行数据拷贝移动
        elementData[--size] = null;

        return oldValue;*/

    arrayList.add(1, "add");//源码同上，直接移动拷贝


    /**
     * 场景三：
     * 非安全线程，多线程操作时，可能会数据操作失误。
     */
    Object setOldValue = arrayList.set(2, "set");
    /*源码：
    没有进行，加锁操作，所以不安全
    public E set(int index, E element) {
        rangeCheck(index);
        E oldValue = elementData(index);
        elementData[index] = element;
        return oldValue;
    }*/
}

2、LinkedList特点详解

存储结构：链表存储

线程安全：非安全线程

查询速度：速度慢

更新删除：速度快

/**
 * 1、数据结构，双向链表存储结构
 * 3、速度：add，remove，较快，get，，较慢
 * 4、线程安全：不是安全线程
 */
private void testLinkedList() {
    /**
     * 场景一：
     *add，remove双向链表插入，删除
     */
    LinkedList linkedList = new LinkedList<>();
    linkedList.add("add");
   /*源码：
    void linkLast(E e) {
        final LinkedList.Node<E> l = last; //上一个节点
        final LinkedList.Node<E> newNode = new LinkedList.Node<>(l, e, null); //存储当前节点
        last = newNode;                     //更新上一个节点为
        if (l == null)
            first = newNode;
        else
            l.next = newNode;
        size++;
        modCount++;
    }*/


    /**
     * 场景二：
     * get查询较慢，双向链表查询
     */
    linkedList.get(1);
   /*双向链表查询源码：
    Node<E> node(int index) {
        // assert isElementIndex(index);
        if (index < (size >> 1)) {  //链表长度size>>1一位，index比size小
            Node<E> x = first;
            for (int i = 0; i < index; i++) //循环查询下标，获取节点
                x = x.next;//返回下一个节点
            return x;
        } else {
            Node<E> x = last;
            for (int i = size - 1; i > index; i--) //循环查询下标，获取节点
                x = x.prev;
            return x;   //返回上一个节点
        }
}*/

    /**
     * 场景三：
     * 线程安全：非安全线程
     */
    linkedList.set(1, "set");
   /*源码：无线程安全
    public E set(int index, E element) {
        checkElementIndex(index);
        Node<E> x = node(index);
        E oldVal = x.item;
        x.item = element;
        return oldVal;
    }*/
}

3、Vector数组(和ArrayList相同，区别：实现了synchronized线程安全)

存储结构：数组存储，

线程安全：非安全线程

查询速度：速度快

更新删除：速度慢

初始化：10个数组空间，后续以5个增加

/**
 * vector和arrayList完全相同
 * 所有修改元素的操作，都进
 */
public void testVector() {
    Vector vector = new Vector();
    vector.add("add");
    vector.set(1, "set");
    vector.remove(0);
    vector.get(1);
    //如下源码，所以的增删改查，都实现了，synchronized 加锁的操作

  /*源码：synchronized
    public synchronized E get(int index) {
    if (index >= elementCount)
        throw new ArrayIndexOutOfBoundsException(index);
    return elementData(index);
}

   public synchronized boolean add(E e) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
    }*/

}

面向开发过程，记录学习之路。