为了有针对性的筹备面试，锁屏面试题百日百刷开始每日从各处收集的面经中抉择几道经典面试题分享并给出答案供参考，答案中会做与题目相干的扩大，并且可能会抛出肯定问题供思考。这些题目我会标注具体的公司、招聘类型以及面试阶段。这些面试题会收录到锁屏面试题app和小程序中。其余面试题每日更新中，多谢应用和反对。官网地址:https://www.demosoftware.cc/#/introductionPage，上面是明天的面试题:
====ArrayList 和 LinkedList 实现原理和前者的扩容机制？阿里云[一面]
以下内容均是以jdk1.8来讲:
ArrayList实现原理:
Arraylist底层是用一个Object数组elementData来保留数据的:
transient Object[] elementData; // non-private to simplify nested class access
从创立一个ArrayList开始看，个别都是通过new即通过构造函数来创立一个ArrayList看源码:
public ArrayList() { this.elementData = DEFAULTCAPACITY_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); }}public ArrayList(Collection<? extends E> c) { elementData = c.toArray(); if ((size = elementData.length) != 0) { // c.toArray might (incorrectly) not return Object[] (see 6260652) if (elementData.getClass() != Object[].class) elementData = Arrays.copyOf(elementData, size, Object[].class); } else { // replace with empty array. this.elementData = EMPTY_ELEMENTDATA; }}很简略，无非就是无参结构只会创立一个空的数组，带初始化数组大小的结构器会创立一个晓得容量的ArrayList,以及用另一个ArrayList初始化新的ArrayList的构造函数。
再看ArrayList的操作:
1)增加:
public boolean add(E e) { ensureCapacityInternal(size + 1); // Increments modCount!! elementData[size++] = e; return true;}private void ensureCapacityInternal(int minCapacity) { if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity); } ensureExplicitCapacity(minCapacity);}private void ensureExplicitCapacity(int minCapacity) { modCount++; // overflow-conscious code if (minCapacity - elementData.length > 0) grow(minCapacity);}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);}这里，modCount是咱们每次对ArrayList做扭转大小的时候会做一次自增操作的变量，记录下批改次数。外围的常问的一个办法就是这个grow()办法，这是当ArrayList中元素的数组(下面讲到的存储数据的)elementData容量不够时做的扩容操作。这里咱们以用空参结构器创立ArrayList时，第一次向ArrayList增加元素时会做一次扩容操作来讲:
判断容量是否足够的就是这么一句:if (minCapacity - elementData.length > 0)
在grow中，外围的一段就是int newCapacity = oldCapacity + (oldCapacity >> 1);新的容量是旧的容量的1.5倍(oldCapacity >> 1实际上是一次oldCapacity除2操作)
留神这里扩容触发条件是在应用无参结构器第一次增加元素，以及增加元素时，判断发现数组长度不够时。
2)删除：
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; // clear to let GC do its work return oldValue; }看代码很简略，就是做一次数组复制，挪动要删除的某一地位元素的前面的元素，并且将旧数组置为null做垃圾回收。指定remove(Object O)这个办法也是先找对应元素的下标，而后做与下面代码差不多的操作。有趣味的能够看下源码。
查问就没啥好讲的了，底层是数组存储，查问很容易做到。可自行看源码。
LinkedList实现原理:
LinkedList存储是通过双向链表实现的:
transient Node<E> first;transient Node<E> last;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; } }它的空参结构不做任何操作，带参结构LinkedList(Collection<? extends E> c)也是着重体现在增加元素的操作，所以间接讲它的一些操作，这里须要大家可能懂链表的增删改查的操作，因为LinkedList的这些操作就是依据这些来的。心愿大家可能找一下材料理解下，这里篇幅无限，不作解说。
1)增加：
头部增加:
public void addFirst(E e) { linkFirst(e); }private void linkFirst(E e) { final Node<E> f = first; final Node<E> newNode = new Node<>(null, e, f); first = newNode; if (f == null) last = newNode; else f.prev = newNode; size++; modCount++;}看下下面对于LinkedList一开始讲的，能够看到LinkedList成员变量就有保留first和last，这里从头部插入和从尾部插入基本上操作统一，只是保留地位不同，看代码很容易看懂，就是对链表的操作，至于add()办法是在尾部插入新的元素。
2)删除
removeFirst()和removeLast()以及remove()(remove和removeFirst()操作统一)，都是简略去链表表头或表尾的操作，能够本人看源码，相熟链表操作的同学很容易就能看懂，不作赘述。说一说remove(int index)：
public E remove(int index) { checkElementIndex(index); return unlink(node(index)); }Node<E> node(int index) { // assert isElementIndex(index);// 这里是做了一个减速查找的操作// 获取index处的节点。 // 若index < 双向链表长度的1/2,则从前先后查找; // 否则，从后向前查找。 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; } }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;}这里是先依据index找到LinkedList中存储的节点，见上图node()办法，而后开始删除元素操作，见unlink()办法，相熟链表的删除操作，很容易能看懂，判断删除的元素是否是表头后表尾，是的话简略的赋值一下即可，不是的话做相应的删除操作。Remove(Object o)这个办法也是先找到这个list中是否有这个元素，先通过查找，再调用unlink()办法删除。
3）查找
LinkedList查找操作在下面的删除操作中，先查找在做删除的步骤中曾经讲过(下面的node办法)，请自行对照源码查看查找操作。