线性数据结构

一般将数据结构分为两在类：线性数据结构和非线性数据结构。线性数据结构有线性表、栈、队列、串、数组和文件；非线性数据结构有树和图。

线性表

• 线性表的逻辑结构是n个数据元素的有限序列。
• 数据元素呈线性关系。必存在惟一的称为“第一个”的数据元素；必存在惟一的称为“最后一个”的数据元素；除了第一个元素外，每个元素都有且只有一个前驱元素；除了最后一个元素外，每个元素都有且只有一个后继元素。
• 所有数据元素在同一个线性表中必须是相同的数据类型。
• 线性表按其存储结构可分为顺序表和链表。用顺序存储结构存储的线性表称为顺序表；用链式存储结构存储的线性表称为链表。
• 将线性表中的数据元素依次存放在某个存储区域中，所形成的表称为顺序表。一维数组就是用顺序方式存储的线性表。

一、ArrayList

1、ArrayList底层采用数组实现，当使用不带参数的构造方法生成ArrayList对象时，实际上会在底层生成长度为10的Object类型数组。

Object类型数组

private transient Object[] elementData;

不带参数的构造方法

public ArrayList() {
    this(10);
}

实际调用的方法

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

2、如果增加的个数超过10个，那么ArrayList底层会新生成一个数组，长度为原数组的1.5倍+1，然后将原数组的内容复制到新数组中，后续增加的内容都会放到新组中。当新数组无法容纳增加的元素时，重复该过程。

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

private void ensureCapacityInternal(int minCapacity) {
    modCount++;
    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

JDK7已更新了新数组长度的算法

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

3、ArrayList的三个构造函数

ArrayList() 建立一个空的数组列表

ArrayList(int capacity)  建立一个数组列表，有指定的初始容量(capacity)。容量是用于存储元素的基本数组的大小。当元素被追加到数组列表上时，容量会自动增加。

ArrayList(Collection c) 建立一个数组列表，由类集c中的元素初始化。如可放入一个LinkedList。

4、获取元素，检查是否有该无素，有的话则直接取数组的元素。

public E get(int index) {
    rangeCheck(index);

    return elementData(index);
}

private void rangeCheck(int index) {
    if (index >= size)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

5、ArrayList元素的删除操作，需将被删除元素的后续元素向前移动，代价比较高。

    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; // Let gc do its work

        return oldValue;
    }

6、集合中只能放置对象的引用，无法放置原生数据类型，需要使用原生数据类型的包装类才能加入到集合中。

二、LinkedList

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

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

三、ArrayList与LinkedList的比较分析

1、ArrayList底层采用数组实现，LinkedList底层采用双向链表实现。

2、当执行插入或者删除操作时，采用LinkedList比较好。

3、当执行搜索操作时，采用ArrayList比较好。