前言

实习即将结束,要开始为之后的春招做准备了,巩固下基础.

LinkedList和ArrayList是开发中常见的集合类,今天我就从源码分析一下两者的优缺点和不同之处.

正文

• 增:

  ArrayList

    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
  
    private void ensureCapacityInternal(int minCapacity) {
        if (elementData == EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        ensureExplicitCapacity(minCapacity);
    }
  
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
  
    private void grow(int minCapacity) {
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity); 
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
  

我们发现ArrayList的add方法中调用了ensureCapacityInternal方法,最终调用了grow方法.我们都知道ArrayList的本质其实还是对数组的操作,而数组的长度是不可改变的,当我们加入的元素超出数组本身的长度,它会根据数组当前长度的一半进行扩容,也就是grow方法,然后添加进数组.

grow通过下面这句代码扩容,将旧数组通过copyof方法拷贝,并赋予一个新的长度newCapacity,生成一个新的数组.

elementData = Arrays.copyOf(elementData, newCapacity);
//将新增的元素加入数组
elementData[size++] = e;

LinkedList:

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

LinkedList是一个双链表模式的集合,而通过代码,我们不难看出,每当你为集合新增一个元素,它只需要将末端元素的next指向添加的元素即可.

我们不难看出,在增这一项上LinkedList在效率上无疑是大于ArrayList的,它不需要考虑长度不够时的扩容,也不需要将旧数组拷贝赋予新数组,只需要将指针指向新的元素即可.

• 删:

  ArrayList:

  public E remove(int index) {
    if (index >= size)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    modCount++;
    E oldValue = (E) elementData[index];
    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,numMoved);
    elementData[--size] = null;
    return oldValue;
  

  }

我们发现,在判断是否越界后,ArrayList通过拷贝将index后的所有元素提前一位,并将原数组的最后一个元素置空,方便虚拟机回收.

LinkedList:

 public E remove(int index) {
    checkElementIndex(index);
    return unlink(node(index));
}

E unlink(Node<E> x) {
    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;
}

通过代码,我们发现,LinkedList在删除时,直接将要删除的前一个元素指向要删除的后一个元素,举个栗子.共有1、2、3三个元素，通过链表的表示方法是，1->2->3,我们删除时,只需要将链表改为1->3,之后将2这个元素置空即可.并不需要像ArrayList那样通过拷贝的方法去删除.

所以,在删除这个操作上,LinkedList在效率上无疑要大于ArrayList的.

• 改:

  ArrayList:

  public E set(int index, E element) {
    if (index >= size)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
  
    E oldValue = (E) elementData[index];
    elementData[index] = element;
    return oldValue;
    }
  

通过代码我们发现,ArrayList在改操作是非常简单的,直接通过引用的方式替换.

LinkedList:

 public E set(int index, E element) {
    checkElementIndex(index);
    Node<E> x = node(index);
    E oldVal = x.item;
    x.item = element;
    return oldVal;
}

 Node<E> node(int 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;
    }
}

相较于ArrayList来说,LinkedList无疑显得非常的复杂,通过node方法查找元素,之后直接通过引用替换,但是在查找元素时无疑是非常耗时的,通过代码我们发现,它是通过遍历链表一个一个对比.虽然做了一些优化,在查找之前先判断了index元素是属于链表的前半区,还是后半区.但相对于ArrayList在效率上无疑是不如的.

• 查:

  ArrayList:

    public E get(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
  
        return (E) elementData[index];
    }
  

直接通过数组查找然后强转.

`LinkedList`:
public E get(int index) {
    checkElementIndex(index);
    return node(index).item;
}
Node<E> node(int 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;
    }
}

之前在改操作的时候已经分析了查找时的缺点,就不在分析了.

总得来说,ArrayList与LinkedList的优缺点如下表:

通过表格我们可以看出2中集合的优缺点,ArrayList更适用于大量改查操作的情况,而LinkedList更使用于大量增删操作的情况.

结语

在分析的过程中,LinkedList感觉可以在查的时候进行优化,通过算法去优化LinkedList本身的不足,通过各种查找算法去优化.