java集合：ArrayList 和LinkedList的区别

从线程安全的方面来说，这两个都不能线程安全的；
从数据结构来说，ArrayList 的底层使用的是object数组，而LinkedList底层是双向链表数据结构。
由于ArrayList是底层是数组，所以可以快速随机访问，通过坐标就可以快速定位，而LinkedList 则不可以。
在添加和删除方面，ArrayList 是数组结构，如果添加/删除的是第i个数据，那么数组中的i之后的所有数据都会向前后移动。而链表结构则不会。所以LinkedList做添加删除快速。
ArrayList会在尾部预留一定的容量空间，因为如果做添加操作的时候，超出当前数组最大值时，会添加50%的空间。LinkedList的空间花费则体现在它的每一个元素都需要消耗比ArrayList更多的空间（因为要存放直接后继和直接前驱以及数据

其次再说一下遍历，一般ArrayList优先使用普通for循环。而LinkedList优先选择iterator遍历（foreach遍历底层也是通过iterator实现的），大size的数据，千万不要使用普通for循环

那么为什么是这样子呢？这是我们普通使用的循环

List<Integer> arrayList = new ArrayList<Integer>();// List<Integer> linkedList = new LinkedList<Integer>();
    
    for (int i = 0; i < 100; i++)
    {
        arrayList.add(i);
    }
    for (int i = 0; i < 100; i++)
    {
        System.out.println(arrayList.get(i));
    }

如果是普通arrylist 使用for循环我们从底层代码来看。arrayList就是数组从指定位置上拿数据，假设我们给ArrayList的get方法时间复杂度设为O(1) 那么每一个都是o1。

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

return (E) elementData[index];
}

但是如果是LinkedList 底层是双链表结构，由此看出如果查询的数据是在前半部分就循环前面，如果在后半部分就循环后面，

public E get(int index) {
    return entry(index).element;
}

  private Entry<E> entry(int index) {
      if (index < 0 || index >= size)
          throw new IndexOutOfBoundsException("Index: "+index+
                                              ", Size: "+size);
      Entry<E> e = header;
      if (index < (size >> 1)) {
          for (int i = 0; i <= index; i++)
              e = e.next;
      } else {
         for (int i = size; i > index; i--)
             e = e.previous;
     }
     return e;
 }

分析一下为什么使用普通for循环遍历LinkedList会这么慢。

以前者为例：

1、get(0)，直接拿到0位的Node0的地址，拿到Node0里面的数据

2、get(1)，直接拿到0位的Node0的地址，从0位的Node0中找到下一个1位的Node1的地址，找到Node1，拿到Node1里面的数据

3、get(2)，直接拿到0位的Node0的地址，从0位的Node0中找到下一个1位的Node1的地址，找到Node1，从1位的Node1中找到下一个2位的Node2的地址，找到Node2，拿到Node2里面的数据。

后面的以此类推。

也就是说，LinkedList在get任何一个位置的数据的时候，都会把前面的数据走一遍。假如我有10个数据，那么将要查询1+2+3+4+5+5+4+3+2+1=30次数据，相比ArrayList，却只需要查询10次数据就行了，随着LinkedList的容量越大，差距会越拉越大。其实使用LinkedList到底要查询多少次数据，大家应该已经很明白了，来算一下：按照前一半算应该是（1 + 0.5N） * 0.5N / 2，后一半算上即乘以2，应该是（1 + 0.5N） * 0.5N = 0.25N² + 0.5N，忽略低阶项和首项系数，得出结论，LinikedList遍历的时间复杂度为O(N²)，N为LinkedList的容量。

时间复杂度有以下经验规则：

O(1) < O(log₂N) < O(n) < O(N * log₂N) < O(N²) < O(N³) < 2N < 3N < N!

前四个比较好、中间两个一般、后3个很烂。也就是说O(N²)是相对糟糕的一种时间复杂度了，N大一点，程序就会执行得比较慢。

并且通过测试得出

数据量	1000	5000	10000	50000	100000
ArrayList	0ms	1ms	2ms	3ms	3ms
LinkedList	3ms	16ms	88ms	2446ms	18848ms

从运行结果我们看到，按倍数增大List容量，ArrayList的遍历显得比较稳定，而LinkedList的遍历几乎是爆发式的增长，再测试下去已经没有必要了。

另外看到 RandomAccess接口

public interface RandomAccess {
}

里面什么都没有定义，那么它其实就是一个标识，用来标识是否具有随机访问功能。

在binarySearch（）方法中，它要判断传入的list 是否RamdomAccess的实例，如果是，调用indexedBinarySearch（）方法，如果不是，那么调用iteratorBinarySearch（）方法

    public static <T>
    int binarySearch(List<? extends Comparable<? super T>> list, T key) {
        if (list instanceof RandomAccess || list.size()<BINARYSEARCH_THRESHOLD)
            return Collections.indexedBinarySearch(list, key);
        else
            return Collections.iteratorBinarySearch(list, key);
    }

ArrayList 实现了 RandomAccess 接口，而 LinkedList 没有实现。为什么呢？我觉得还是和底层数据结构有关！ArrayList 底层是数组，而 LinkedList 底层是链表。数组天然支持随机访问，时间复杂度为 O（1），所以称为快速随机访问。链表需要遍历到特定位置才能访问特定位置的元素，时间复杂度为 O（n），所以不支持快速随机访问。，ArrayList 实现了 RandomAccess 接口，就表明了他具有快速随机访问功能。 RandomAccess 接口只是标识，并不是说 ArrayList 实现 RandomAccess 接口才具有快速随机访问功能的！

下面再总结一下 list 的遍历方式选择：

实现了RandomAccess接口的list，优先选择普通for循环，其次foreach,
未实现RandomAccess接口的ist，优先选择iterator遍历（foreach遍历底层也是通过iterator实现的），大size的数据，千万不要使用普通for循环

以上内容来自：https://snailclimb.top/JavaGuide/#/./java/collection/Java集合框架常见面试题

http://www.cnblogs.com/xrq730/p/5189565.html

感谢

java集合：ArrayList 和LinkedList的区别

猜你喜欢