Java集合源码 -- List列表

List概述

List是一个有序，可重复的集合,可以在List的中间插入和移除元素,根据整数索引访问元素

下图是List集合的框架图

下面是对上图的简单介绍

AbstractCollection: 提供 Collection 接口的骨干实现

Iterator: 迭代器
ListIterator：列表迭代器

Queue：队列
Deque：一个线性 collection，支持在两端插入和移除元素

AbstractSequentialList：提供了 List 接口的骨干实现
LinkedList：链表的实现

ArrayList：大小可变数组的实现

Vector：实现可增长的对象数组
Stack：后进先出（LIFO）的对象堆栈

ArrayList

底层存储

属性 elementData 存储集合中的内容

 /**  缓存区:存储元素 */
 private transient Object[] elementData;

将元素添加到指定位置

将元素添加到指定位置后, 把原数组中 该位置和之后的元素 向后移动一位

/** 在指定位置添加元素 */
public void add(int index, E element) {
        rangeCheckForAdd(index);          //判断索引位置是否正确

        ensureCapacityInternal(size + 1);  // 扩容

        //对原数组进行复制处理（位移），从index + 1到size-index
        //即向右移动当前位于该位置的元素以及所有后续元素。
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        elementData[index] = element;  //插入
        size++;
    }

介绍下 System.arraycopy(......)

/**
即从指定源数组中复制一个数组，
复制从指定的位置开始，到目标数组的指定位置结束。
将原数组src从srcPos位置开始复制到dest数组中，到dest的destPos位置开始,复制的长度为length
*/
public static native void arraycopy(Object src,  int  srcPos, Object dest, int destPos, int length);

删除指定位置的元素

删除元素后, 把原数组中 该位置之后的元素 向前移动一位

public E remove(int index) {
        rangeCheck(index);     //判断移动位置

        modCount++;    //记录改变次数
        E oldValue = elementData(index);   //要删除的元素

        int numMoved = size - index - 1;   //移动的长度

        //向左移动numMoved个长度
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; //把最后一个元素设为null

        return oldValue;
    }

扩容

首先扩容为原来的1.5倍, 在检查新容量,  最大容量为Integer.MAX_VALUE

private void grow(int minCapacity) {
    ...
    int newCapacity = oldCapacity + (oldCapacity >> 1); //将新的容量变为原来容量的1.5倍。
    ...
    hugeCapacity(int minCapacity);
}

//对扩容后的容量进行检查
private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) //得到的容量<0，为什么会有这种情况，内存溢出了。
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?  //如果需要的容量比规定的最大容量大，那么最大容量只能是 Integer.MAX_VALUE。
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
}

动态扩容，其实是一个新数组; 在清楚业务,插入的数据量大于扩容后的1.5倍, 应该自己设置一个合适容量

Vector 和 Stack

概述

Vector可以看做ArrayList的同步实现, 具体可参考ArrayList的分析

Stack类提供了栈的结构, 表示先进后出的操作方法

Stack 继承 Vector , 它定义了5个方法并且调用的都是父类中的方法, 下面是方法定义

E push(E item)    //把对象压入栈顶部, 内部调用是父类的 addElement(item)
E pop()           //移除栈顶对象,内部调用是父类的 removeElementAt(int index)
E peek()          //查看栈顶的对象,内部调用是父类的 elementAt(int index)
int search(Object o) // 返回对象在堆栈中的位置,内部调用父类lastIndexOf(Object o)
empty()             // 测试堆栈是否为空

自定义Stack

/**
 * 自定义Stack
 */
public class MyStack {
    private static final int CAPACITY = 3;
    private static Object[] array = new Object[CAPACITY];
    private static int top = -1;

    /** 把对象压入栈顶  */
    void push(Object o) throws Exception {
        if(getSize() == CAPACITY) {
            throw new ExceptionStack("stack is full");
        }

        array[++top] = o;
    }

    /** 移除栈顶元素 */
    Object pop() throws Exception {
        if(isEmpty()) {
            throw new ExceptionStack("stack is empty");
        }
        return array[top--];

    }

    /** 查看栈顶元素  */
    Object peek() throws Exception {
        if(isEmpty()){
            throw new ExceptionStack("Stack is empty");
        }
        return array[top];
    }

    /** 判断尺寸已满 */
    int  getSize() {
        if(isEmpty()){
            return 0;
        }else{
            return top + 1;
        }
    }

    /** 判断为空 */
    boolean isEmpty() {
        return (top < 0);
    }

    public static void main(String[] args) throws Exception {
        MyStack s = new MyStack();
        System.out.println(s.isEmpty());

        s.push("1");
        s.push("2");
        s.push("3");

        System.out.println(s.isEmpty());
        System.out.println(s.getSize());
        System.out.println(s.pop());
        System.out.println(s.peek());
    }
}

自定义异常类:

public class ExceptionStack extends Exception{

    //Define myself exception construct with parameters
    public ExceptionStack(String string){
        super(string);
    }
}

LinkedList

LinkedList 的内部实现是双向链表,它允许null的存在,它的方法是不同步的

与ArrayList相比,在插入和删除时优于ArrayLis, 而随机访问则比ArrayList逊色些

主要属性

transient int size = 0;     //集合长度
transient Node<E> first;    //头节点
transient Node<E> last;     //尾节点

介绍下静态内部类Node

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;
        }
    }

构造方法

分析下:  LinkedList(Collection<? extends E> c)  构造一个包含指定 collection 中的元素的列表

最终调用的是  addAll(..) ,如下:

 public boolean addAll(int index, Collection<? extends E> c) {
         checkPositionIndex(index); //判断下表越界

         Object[] a = c.toArray();  //把c转为数组
         int numNew = a.length;    //numNew为数组长度
         if (numNew == 0)
             return false;

         Node<E> pred, succ;   

         if (index == size) {  //在构造的调用过程中,肯定是相等的
             succ = null;
             pred = last;  //pred指向尾节点
         } 

         /*  注释的是构造时不执行的
         else {
             succ = node(index);
             pred = succ.prev;
         }
         */

         for (Object o : a) {
             E e = (E) o;    //从数组中取出元素
             Node<E> newNode = new Node<>(pred, e, null);  //创建新节点

             /*
             if (pred == null)
                 first = newNode;
             */
             else
                 pred.next = newNode;  //原尾节点的后一个节点指向新节点
             pred = newNode;   //pred成了新节点
         }

         if (succ == null) {
             last = pred;   //last是添加c后的尾节点
         } 

         /*
         else {
             pred.next = succ;
             succ.prev = pred;
         }
         */

         size += numNew;    //修改容量
         modCount++;     //修改次数+1
         return true;
     }

node(int index) 返回指定位置的节点

node(int index) 很重要, 添加,删除等操作都会用到, 下面就介绍它

　　/**
        返回指定位置的节点
    */
    Node<E> node(int index) {

        //判断遍历的方向
        if (index < (size >> 1)) {    //  size >> 1  = siz2 /2
            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;
        }
    }

添加

add(E e ): 把节点加到链表的最后 ，实际上调用的是linkLast(E e)方法

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++;      //链表总数+1
    modCount++;
 }    

add(int index, E element): 把数据插入指定的位置,实际上调用的是 linkBefore(element, node(index))

/**
    参数1: 代表新元素
    参数2: succ 代表指定位置的节点
*/
void linkBefore(E e, Node<E> succ) {

        final Node<E> pred = succ.prev;   //把指定位置的前一个节点保存在pred
        final Node<E> newNode = new Node<>(pred, e, succ);  //创建新节点
        succ.prev = newNode;   //指定新节点的后一个节点
        if (pred == null)
            first = newNode;
        else
            pred.next = newNode;  //指定新节点的前一个节点
        size++;
        modCount++;
}

删除

remove(Object o):  从此列表中移除首次出现的指定元素, 实际上调用的是 unlink(Node<E> x)

/**
 参数: 要移除的节点
*/
 E unlink(Node<E> x) {

        final E element = x.item;
        final Node<E> next = x.next;    // 保存 移除节点 的后一个节点 在变量next中
        final Node<E> prev = x.prev;    //保存 移除节点 的前一个节点  在变量prev中

        if (prev == null) {   //true代表 移除节点 是头节点
            first = next;
        } else {
            prev.next = next;    // 将 prev后一个节点 指向next
            x.prev = null;      // 将 移除节点的prev设为空
        }

        if (next == null) {  //true代表移除节点是尾节点
            last = prev;
        } else {
            next.prev = prev;  //将 next前一个节点 指向prev
            x.next = null;    //将 移除节点的next 设为空
        }

        x.item = null;  //将移除节点的元素 设为空
        size--;
        modCount++;
        return element;   //返回移除的元素
    }    

总结

对LinkedList的操作实际上是对指向前节点和后节点的引用操作,所以其插入和删除效率较高，但是随机访问效率较差，因为要遍历