ArrayList LinkedList源码分析,性能分析

ArrayList LinkedList源码分析,性能分析

原博地址

Java中常用到ArrayList和LinkedList,面试中也常问到两者的区别,各自的使用场景。要想清楚的明白他们的区别,那还是得从源码入手。

1. List接口

List接口中的方法有很多,但最重要的无非是增删查改,我们从ArrayList与LinkedList的实现上来讨论他们的增删查改性能问题。先列出这几个重要的方法:

public interface List<E> extends Collection<E> {
    ...
    //增
    boolean add(E e); 
    void add(int index, E element);
    //查
    E get(int index);
    //改
    E set(int index, E element);
    //删
    E remove(int index);
    boolean remove(Object o);
    ...
}

2. ArrayList

2.1 构造函数

ArrayList底层使用的是动态数组,我们常用到的构造方法一般是如下两种:

/**
     * Shared empty array instance used for default sized empty instances. We
     * distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
     * first element is added.
     */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
/**
     * Shared empty array instance used for empty instances.
     */
    private static final Object[] EMPTY_ELEMENTDATA = {};

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

从源码可以看出,两者的区别在于初始化数组的长度,前者给定一个空数组,后者若initialCapacity大于0即给定一个initialCapacity大小的数组。
同时,第一段源码的注释还提到了,使用DEFAULTCAPACITY_EMPTY_ELEMENTDATAEMPTY_ELEMENTDATA是为了不同的扩展策略。

2.2 添加一个元素
private int size;

    public boolean add(E e) {
        //增加一个元素首先得保证底层数组不越界
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

    private static final int DEFAULT_CAPACITY = 10;

    private void ensureCapacityInternal(int minCapacity) {
        //之前使用的是ArrayList()作为构造函数的话,第一次扩展把空数组扩展成size=10的数组
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }

    private void ensureExplicitCapacity(int minCapacity) {
        //这个变量记录了对ArrayList修改的次数(Fail-Fast 就是检测的这个变量)
        modCount++;

        //当前数组已没有更多的容量,则需要动态扩展
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        //即newCapacity =1.5倍oldCapacity,所以ArrayList每次动态扩展是1.5倍的扩展 
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // ArrayList不适合Add很多的场景,每当底层数组扩容后需要把所有的元素从老数组copy到新数组
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

添加元素时会检测数组大小是否满足条件,不满足会去新建一个更大的数组,把原来数组中的元素都copy过来,可以看出,对于ArrayListadd操作来讲,是比较低效的(当需要扩容时)。
另外还有个public void add(int index, E element)方法,它在指定位置add元素时,需要把指定位置后面的所有元素都往后移动一个位置,所以也是比较低效的。

2.3 读取一个元素
    public E get(int index) {
        rangeCheck(index);

        return elementData(index);
    }

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

    E elementData(int index) {
        return (E) elementData[index];
    }

可以看到,ArrayListGet是非常高效的,只要index没有越界,直接从底层数组中返回即可,这也是ArrayList的优势所在。

2.4 修改一个元素
    public E set(int index, E element) {
        rangeCheck(index);

        E oldValue = elementData(index);
        elementData[index] = element;
        return oldValue;
    }

ArrayListSet也很高效,直接往数组中写即可。

2.5 删除一个元素
public E remove(int index) {
        rangeCheck(index);

        modCount++;
        E oldValue = elementData(index);

        int numMoved = size - index - 1;
        if (numMoved > 0)
            //把index后面的元素整体向前移动,可以看出这步是非常耗资源的
            System.arraycopy(elementData, index+1, elementData, index, numMoved);

        //放弃对最后一个元素的引用,让GC能回收掉它
        elementData[--size] = null; // clear to let GC do its work

        return oldValue;
    }

ArrayList在做删除操作时,因为需要把后面的所有元素整体前移来填空,所也也是非常耗资源的。
另外还有个public boolean remove(Object o)方法,这个是做一次遍历查询,然后删除。


3. LinkedList

3.1 构造函数

通过名字就可知道,LinkedList底层使用的是链表的形式去实现的,它的构造函数什么也没干:

/**
     * Constructs an empty list.
     */
    public LinkedList() {
    }
3.2 添加一个元素
public boolean add(E e) {
        linkLast(e);
        return true;
    }

    transient Node<E> last;    
    transient Node<E> first;

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

代码还是很简单的,add一个元素就直接把这个元素放到链表的末端即可。但需要注意的是,相对于ArrayListadd方法,LinkedListadd方法并不见得高效,而且当数据量大后还远慢于ArrayList
同时,LinkedList还是双向链表,所以内部同时保留了transient Node<E> lasttransient Node<E> first的引用。

3.3 读取一个元素
public E get(int index) {
        checkElementIndex(index);
        return node(index).item;
    }

    private void checkElementIndex(int index) {
        if (!isElementIndex(index))
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

    private boolean isElementIndex(int index) {
        return index >= 0 && index < size;
    }

    Node<E> node(int index) {
        // assert isElementIndex(index);
        // 看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;
        }
    }

读取元素的代码也比较简单,首先check index是否合法,然后遍历链表查找对应元素,查找时用到点小技巧,通过查看index更靠近链表的哪一端,决定从哪一端去遍历。LinkedList在查找时需要遍历,所以相对于ArrayList的随机存取来说,会低效一些。

3.4 修改一个元素
    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)这个方法去遍历查找,所以也是相对低效的。

3.5 删除一个元素
public E remove(int index) {
        checkElementIndex(index);
        return unlink(node(index));
    }

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

首先查找到这个元素(同样使用到了Node<E> node(int index)去查询),然后把它从链表里断出来。因为有遍历查询的存在,所以效率也不会很高。但相对于ArrayList的整块元素的copy来说,效率应该会好一些。

4. 性能试验

4.1 顺序添加(boolean add(E e)

从源码中分析可以得出时间复杂度:
- LinkedList:O(1)
- ArrayList:O(1) amortized, but O(n) worst-case since the array must be resized and copied

咋一看,感觉LinkedList的性能应该优于ArrayList,但实验结做下来却不是这样。这里分别向两个List中添加大量元素:

public static void main(String[] args) throws CloneNotSupportedException {

        sequenceAdd();

    }

    private static void sequenceAdd() {

        int[] arr = new int[100000000];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) (Math.random() * 100);
        }

        Long start = System.currentTimeMillis();
        ArrayList<Integer> arrayList = new ArrayList<Integer>();
        for(int temp : arr){
            arrayList.add(temp);
        }
        System.out.println((System.currentTimeMillis() - start)/1000.0 + "s");

        Long start2 = System.currentTimeMillis();
        LinkedList<Integer> LinkedList = new LinkedList<Integer>();
        for(int temp : arr){
            LinkedList.add(temp);
        }
        System.out.println((System.currentTimeMillis() - start2)/1000.0 + "s");

    }
ArrayList: 0.631s
LinkedList: 26.14s

通过结果可以看出,LinkedList慢了不止一点。开始怀疑是GC的原因,分别注释重试后发现仍然不是一个量级上的,LinkedList就是慢了许多。

下面是把初始元素个数少去10倍和100倍的情况,从结果可以看出,当数据量少去100倍后两个List的耗时回归同一量级了。

ArrayList: 0.081s
LinkedList: 3.005s
ArrayList: 0.01s
LinkedList: 0.014s

所以对于顺序添加boolean add(E e)来说,ArrayList的效率是优于LinkedList的。造成这种现象的原因我觉得是,LinkedList每次都需要去给Node分配内存所以不见得会快。而ArrayList在经历了一次次扩容后,数据量越大,后面的扩容次数反而降了下来,而且对于数组的复制这种方法,底层应该是做了不少优化。

4.2 随机添加(void add(int index, E element)

从源码中分析可以得出时间复杂度:
- LinkedList:O(n/4) average
- ArrayList:O(n/2) average

private static void randomAdd() {

      //准备数据
      int[] arr = new int[100000000];
      for (int i = 0; i < arr.length; i++) {
          arr[i] = (int) (Math.random() * 100);
      }
      ArrayList<Integer> arrayList = new ArrayList<Integer>();
      for(int temp : arr){
          arrayList.add(temp);
      }
      LinkedList<Integer> LinkedList = new LinkedList<Integer>();
      for(int temp : arr){
          LinkedList.add(temp);
      }

      Random random =new Random();
      //ArrayList随机add
      Long start = System.currentTimeMillis();
      for(int i=0; i<100; i++){
          arrayList.add(random.nextInt(999999), 999);
      }
      System.out.println("ArrayList: " + (System.currentTimeMillis() - start)/1000.0 + "s");

      //LinkedList随机add
      Long start2 = System.currentTimeMillis();
      for(int i=0; i<100; i++){
          LinkedList.add(random.nextInt(999999), 999);
      }
      System.out.println("LinkedList: " + (System.currentTimeMillis() - start2)/1000.0 + "s");

  }
ArrayList: 5.359s
LinkedList: 0.144s

从结果中可以看出,对于随机插入void add(int index, E element)LinkedList的效率是优于ArrayList的。对于这个结果还是好理解,LinkedList只需要遍历到index的位置,在链表中插入一个Node即可,而ArrayList需要移动整块的元素。但把数据量减少100倍后,两者的效率也差不多了。

4.3 随机访问(E get(int index)

从源码中分析可以得出时间复杂度:
- LinkedList:O(n/4) average
- ArrayList:O(1) <— main benefit of ArrayList

private static void get() {

      //准备数据
      int[] arr = new int[100000000];
      for (int i = 0; i < arr.length; i++) {
          arr[i] = (int) (Math.random() * 100);
      }
      ArrayList<Integer> arrayList = new ArrayList<Integer>();
      for(int temp : arr){
          arrayList.add(temp);
      }
      LinkedList<Integer> LinkedList = new LinkedList<Integer>();
      for(int temp : arr){
          LinkedList.add(temp);
      }

      Random random =new Random();
      //ArrayList随机get
      Long start = System.currentTimeMillis();
      for(int i=0; i<100; i++){
          arrayList.get(random.nextInt(999999));
      }
      System.out.println("ArrayList: " + (System.currentTimeMillis() - start)/1000.0 + "s");

      //LinkedList随机get
      Long start2 = System.currentTimeMillis();
      for(int i=0; i<100; i++){
          LinkedList.get(random.nextInt(999999));
      }
      System.out.println("LinkedList: " + (System.currentTimeMillis() - start2)/1000.0 + "s");

  }
ArrayList: 0.0s
LinkedList: 0.133s

可以看到ArrayList的随机访问完胜。而LinkedList由于需要遍历,所以会慢一些,O(n/4) 的平均时间复杂度是因为LinkedList会检查index离哪端近,从近的那端去遍历。

4.4 随机修改(E set(int index, E element)

原理和上面的随机访问一致,所以性能也和上面一致。

4.5 随机删除(E remove(int index)

从源码中分析可以得出时间复杂度:
- LinkedList:O(n/4) average
- ArrayList:O(n/2) average

private static void remove() {

      //准备数据
      int[] arr = new int[100000000];
      for (int i = 0; i < arr.length; i++) {
          arr[i] = (int) (Math.random() * 100);
      }
      ArrayList<Integer> arrayList = new ArrayList<Integer>();
      for(int temp : arr){
          arrayList.add(temp);
      }
      LinkedList<Integer> LinkedList = new LinkedList<Integer>();
      for(int temp : arr){
          LinkedList.add(temp);
      }

      Random random =new Random();
      //ArrayList随机get
      Long start = System.currentTimeMillis();
      for(int i=0; i<100; i++){
          arrayList.remove(random.nextInt(999999));
      }
      System.out.println("ArrayList: " + (System.currentTimeMillis() - start)/1000.0 + "s");

      //LinkedList随机get
      Long start2 = System.currentTimeMillis();
      for(int i=0; i<100; i++){
          LinkedList.remove(random.nextInt(999999));
      }
      System.out.println("LinkedList: " + (System.currentTimeMillis() - start2)/1000.0 + "s");

  }
ArrayList: 4.455s
LinkedList: 0.11s

原理和随机添加一样,ArrayList在删除中间元素后需要整块移动,LinkedList查询到index后直接删除Node;

4.6 删除指定对象(boolean remove(Object o)
private static void removeSpecific() {

        //准备数据
        int[] arr = new int[100000000];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) (Math.random() * 100);
        }
        ArrayList<Integer> arrayList = new ArrayList<Integer>();
        for(int temp : arr){
            arrayList.add(temp);
        }
        LinkedList<Integer> LinkedList = new LinkedList<Integer>();
        for(int temp : arr){
            LinkedList.add(temp);
        }

        //ArrayList随机get
        Long start = System.currentTimeMillis();
        for(int i=0; i<100; i++){
            arrayList.remove(new Integer((int) (Math.random() * 100)));
        }
        System.out.println("ArrayList: " + (System.currentTimeMillis() - start)/1000.0 + "s");

        //LinkedList随机get
        Long start2 = System.currentTimeMillis();
        for(int i=0; i<100; i++){
            LinkedList.remove(new Integer((int) (Math.random() * 100)));
        }
        System.out.println("LinkedList: " + (System.currentTimeMillis() - start2)/1000.0 + "s");

    }
ArrayList: 4.341s
LinkedList: 0.0s

在删除指定对象时,ArrayListLinkedList都需要去遍历查找,不同的是ArrayList在删除后需要整块移动元素,所以更慢。

5. 总结

  • ArrayList因为是基于动态数组去实现,在随机存取时,有着良好的性能。而增删时需要扩容,整块移动元素,所以相对较慢。但在数据量很大,顺序添加时是个例外,这种情况下它的性能优于LinkedList
  • LinkedList因为是基于链表实现,随机增删较快,而存取时需要遍历查询,相对于ArrayList会更慢。
  • 之后会比较下两种实现的迭代器性能。

对于一开始提到的几种方法,做个总结图表:

add(e)add(index, e)get(index)set(index, element)remove(index)remove(obj)
LinkedListYY
ArrayListYYY

- add(e) 顺序添加
- add(index, e) 随机添加
- get(index) 随机取
- set(index, element) 随机存
- remove(index)随机删除
- remove(obj) 删除指定对象

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值