java集合:ArrayList 和LinkedList的区别
- 从线程安全的方面来说,这两个都不能线程安全的;
- 从数据结构来说,ArrayList 的底层使用的是object数组,而LinkedList底层是双向链表数据结构。
- 由于ArrayList是底层是数组,所以可以快速随机访问,通过坐标就可以快速定位,而LinkedList 则不可以。
- 在添加和删除方面,ArrayList 是数组结构,如果添加/删除的是第i个数据,那么数组中的i之后的所有数据都会向前后移动。而链表结构则不会。所以LinkedList做添加删除快速。
- ArrayList会在尾部预留一定的容量空间,因为如果做添加操作的时候,超出当前数组最大值时,会添加50%的空间。LinkedList的空间花费则体现在它的每一个元素都需要消耗比ArrayList更多的空间(因为要存放直接后继和直接前驱以及数据
那么有一个问题来了,底层数组的大小不够了怎么办?答案就是扩容,这也就是为什么一直说ArrayList的底层是基于动态数组实现的原因 动态数组的意思就是指底层的数组大小并不是固定的,而是根据添加的元素大小进行一个判断,不够的话就动态扩容,扩容的代码就在grow里面(基于Java7):
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);//扩容后 copy到新数组中。 }
其次再说一下遍历,一般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.25N2 + 0.5N,忽略低阶项和首项系数,得出结论,LinikedList遍历的时间复杂度为O(N2),N为LinkedList的容量。
时间复杂度有以下经验规则:
O(1) < O(log2N) < O(n) < O(N * log2N) < O(N2) < O(N3) < 2N < 3N < N!
前四个比较好、中间两个一般、后3个很烂。也就是说O(N2)是相对糟糕的一种时间复杂度了,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
感谢