Java集合 List接口详解

Java List接口详解

Java集合（Collection）接口的重要的三个子接口 List,Set,Queue 。其中List接口的三个重要实现有，ArrayList，LinkedList，Vector。

List的特点是，有序集合，允许放入空值

1，ArrayList类源码分析

ArrayList有三个构造函数，以带int参数的构造函数分析

    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底层的实现方式是数组形式实现的。

其elementData是一个Object 数组。

其中， initialCapacity为初始化容量。new ArrayList时可以定义初始化容量的大小。

ArrayList的size()方法

    public int size() {
        return size;
    }

size初始化为零。当ArrayList添加元素时。

add方法源码

    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

可以看出添加元素时，调用了 ensureCapacityInterna方法，并且size进行自加运算

    private void ensureCapacityInternal(int minCapacity) {
        if (elementData == EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }

    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

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

从添加方法可以分析出来，当ArrayList添加元素时，如果添加数量超过初始化容量时，会自动扩充数组容量， 扩充容量为上次数组大小的1.5倍。并将原数组拷贝成一个新数组

在实际应用上如果ArrayList存储的数据很多时，最好将初始化容量设置的大一些。这样会减少内存消耗。

再看在某一位置添加元素时

    public void add(int index, E element) {
        rangeCheckForAdd(index);

        ensureCapacityInternal(size + 1);  // Increments modCount!!
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        elementData[index] = element;
        size++;
    }

remove方法源码

    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; // clear to let GC do its work

        return oldValue;
    }

可以看出如果在ArrayList里在中间添加或者删除元素时，arrayList会将位置后的所有元素向前（向后）整体位移。在对值进行修改。

所以ArrayList的特点是查找块，添加删除慢。

2,Vector 

vector与ArrayList实现原理相同，都是通过数组形式实现的。只不过vector线程安全（方法加synchronized修饰）。不做源码分析。

3，LinkedList源码分析

LinkedList 实现List接口，和Deque接口（双端队列）,LinkedList 有两个属性  transient Node< E > first ; transient Node< E > last ;

一个是头部的节点，一个是尾部的节点。

节点的源码

    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的实现方式是双向数据链表 形式实现的。特点是添加删除快，查找慢。

add方法

        List list = new LinkedList();
        list.add("123");
        list.add("456");

当我们进行添加操作时;

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

当添加123时，first,last 两个元素都是 null 123 null，且指向相同。

当添加456时将last的值进行修改并且首尾连接

remove方法

    public boolean remove(Object o) {
        if (o == null) {
            for (Node<E> x = first; x != null; x = x.next) {
                if (x.item == null) {
                    unlink(x);
                    return true;
                }
            }
        } else {
            for (Node<E> x = first; x != null; x = x.next) {
                if (o.equals(x.item)) {
                    unlink(x);
                    return true;
                }
            }
        }
        return false;
    }

    E unlink(Node<E> x) {
        // assert x != null;
        final E element = x.item;
        final Node<E> next = x.next;
        final Node<E> prev = x.prev;

        if (prev == null) {
            first = next;
        } else {
            prev.next = next;
            x.prev = null;
        }

        if (next == null) {
            last = prev;
        } else {
            next.prev = prev;
            x.next = null;
        }

        x.item = null;
        size--;
        modCount++;
        return element;
    }

实现方式：先查找删除元素的节点，找到节点后前后节点指向重新赋值。

get方法

    public E get(int index) {
        checkElementIndex(index);
        return node(index).item;
    }

    Node<E> node(int index) {
        // assert isElementIndex(index);

        if (index < (size >> 1)) {
            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;
        }
    }

通过get方法实现可以知道，LinkedList查找时，不是通过下标直接查找，而是 （从头部或者尾部）循环每一个节点进行匹配。

总结：

查找时：ArrayList是直接通过数组下标直接查找，LinkedList是通过循环匹配进行查找的。

添加/删除时：add(e,index)为例ArrayList时，将添加位置后的元素整体向后位移。LinkedList添加元素是找到下标节点创建新的节点插入下标节点和前一个节点之间，重新赋值指向。

ArrayList有初始化容量参数，而LinkedList是双向数据列表，没有初始化容量概念。