万万没想到!!! 谷歌面试原来也问ArrayList

开发 前端
前几天H同学和我聊了下去谷歌的面试经验,令我诧异的是,没想到谷歌也问ArrayList???仔细一想也正常,毕竟集合是Java程序员逃不掉的金光咒。

[[417055]]

本文转载自微信公众号「稀饭下雪」,作者帅气的小饭饭 。转载本文请联系稀饭下雪公众号。

前几天H同学和我聊了下去谷歌的面试经验,令我诧异的是,没想到谷歌也问ArrayList???

仔细一想也正常,毕竟集合是Java程序员逃不掉的金光咒。

看文章前可以先看看以下几个问题,如果觉得莫得问题,可以直接跳过该篇文章了,不用浪费大家时间。

  • ArrayList使用无参构造函数的时候什么时候进行扩容?
  • 说说看ArrayList是扩容的时候是怎么复制数组的?
  • ArrayList遍历删除的时候会触发什么机制?为什么用迭代器遍历删除不会?

好了,接下来继续聊聊高频面试题 ArrayList。

ArrayList的扩容机制

  1. // 存储数组元素的缓冲区 
  2. transient Object[] elementData; 
  3. // 默认空数组元素 
  4. private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; 
  5. // 默认初始化容量 
  6. private static final int DEFAULT_CAPACITY = 10; 
  7. // 数组的大小 
  8. private int size
  9. // 记录被修改的次数 
  10. protected transient int modCount = 0; 
  11. // 数组的最大值 
  12. private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8 

底层ArrayList使用数组实现,不设置的话,默认初始容量为10

  1. // 数组扩容方法 
  2. // minCapacity = size + 1 
  3. private int newCapacity(int minCapacity) { 
  4.     // 当前数组长度 
  5.     int oldCapacity = elementData.length; 
  6.     // 新的数组容量 = 旧数组长度 + 旧数组长度 / 2  
  7.     // oldCapacity = 10   oldCapacity >> 1   --- 5 
  8.     // 例如10的二进制为 :  0000 1010 >> 1  ----->  0000 0101 = 5 
  9.     int newCapacity = oldCapacity + (oldCapacity >> 1); 
  10.     if (newCapacity - minCapacity <= 0) { 
  11.         if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) 
  12.             // 如果一开始没有定义初始容量这时newCapacity=0,返回默认容量10 
  13.             // 可以得出当无参new 一个ArrayList()时候,这个ArrayList()为空集合,size为0 
  14.             return Math.max(DEFAULT_CAPACITY, minCapacity); 
  15.         if (minCapacity < 0) // overflow 
  16.             throw new OutOfMemoryError(); 
  17.         return minCapacity; 
  18.     } 
  19.     return (newCapacity - MAX_ARRAY_SIZE <= 0) 
  20.         ? newCapacity    // 这里返回的长度为原数组的1.5倍 
  21.         : hugeCapacity(minCapacity); 

当增加元素的时候发现底层数组的需要的容量(size+1)大于数组的容量的时候,就会触发扩容,在首次调用add()方法之后,返回一个容量为10的数组,后面每次扩容后新数组的长度为原数组长度的 「1.5」 倍,并调用底层原生的System.arraycopy将旧数组的数据copy到新的数组中,完成整个扩容。

所以日常开发中,在知道初始值的时候先设置初始值,因为扩容是比较耗性能的。

「不用脑子的总结:首次扩容为10 ,后面每次扩容为原数组的1.5倍,调用底层原生的System.arraycopy将旧数组的数据copy到新的数组中,完成整个扩容。」

ArrayList添加元素与扩容

ArrayList.add(E e)源码:

  1. public boolean add(E e) { 
  2.     ensureCapacityInternal(size + 1);  // Increments modCount!! 
  3.     elementData[size++] = e; 
  4.     return true

add()中elementData[size++] = e很好理解,就是将元素插入第size个位置,然后将size++,我们重点来看看ensureCapacityInternal(size + 1)方法;

  1. private void ensureCapacityInternal(int minCapacity) { 
  2.     if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { 
  3.         minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity); 
  4.     } 
  5.     ensureExplicitCapacity(minCapacity); 

ensureCapacityInternal()方法中判断缓存变量elementData是否为空,也就是判断是否是第一次添加元素,如果是第一次添加元素,则设置初始化大小为默认容量10,否则为传入的参数。这个方法的目的就是「获取初始化数组容量」。获取到初始化容量后调用ensureExplicitCapacity(minCapacity)方法;

  1. private void ensureExplicitCapacity(int minCapacity) { 
  2.     modCount++; 
  3.  
  4.     // overflow-conscious code 
  5.     if (minCapacity - elementData.length > 0) 
  6.         grow(minCapacity); 

ensureExplicitCapacity(minCapacity)方法用来判断是否需要扩容,假如第一次添加元素,minCapacity为10,elementData容量为0,那么就需要去扩容。调用grow(minCapacity)方法。

  1. // 数组的最大容量 
  2. private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8; 
  3.  
  4. private void grow(int minCapacity) { 
  5.     // overflow-conscious code 
  6.     int oldCapacity = elementData.length; 
  7.     // 扩容大小为原来数组长度的1.5倍 
  8.     int newCapacity = oldCapacity + (oldCapacity >> 1); 
  9.     // 扩容容量比需要扩容的长度小,则使用需要扩容的容量 
  10.     if (newCapacity - minCapacity < 0) 
  11.         newCapacity = minCapacity; 
  12.     // 扩容容量比最大数组长度大,则使用最大整数长度 
  13.     if (newCapacity - MAX_ARRAY_SIZE > 0) 
  14.         newCapacity = hugeCapacity(minCapacity); 
  15.     // minCapacity is usually close to size, so this is a win: 
  16.     elementData = Arrays.copyOf(elementData, newCapacity); 

grow(minCapacity)方法对数组进行扩容,扩容大小为原数组的1.5倍,如果计算出的扩容容量比需要的容量小,则扩容大小为需要的容量,可以看到,第一次扩容的时候其实是10。如果扩容容量比数组最大容量大,则调用hugeCapacity(minCapacity)方法,将数组扩容为整数的最大长度,然后将elemetData数组指向新扩容的内存空间并将元素复制到新空间,这里使用的是 Arrays.copyOf(elementData, newCapacity)

  1. public static int[] copyOf(int[] original, int newLength) { 
  2.     int[] copy = new int[newLength]; 
  3.     System.arraycopy(original, 0, copy, 0, 
  4.                      Math.min(original.length, newLength)); 
  5.     return copy; 

可以看到底层使用的是System.arraycopy,而这个copy的过程是比较耗性能的,因此建议初始化时预估一个容量大小。

「不用脑子的总结:用无参构造函数创建ArrayList后进行第一次扩容容量是10,后续则是1.5倍,底层调用的是System.arraycopy,而这个copy的过程是比较耗性能的,因此建议初始化时预估一个容量大小。」

ArrayList删除元素

ArrayList提供两种删除元素的方法,可以通过索引和元素进行删除。两种删除大同小异,删除元素后,将后面的元素一次向前移动。

ArrayList.remove(int index)源码:

  1. public E remove(int index) { 
  2.     rangeCheck(index); 
  3.  
  4.     modCount++; 
  5.     E oldValue = elementData(index); 
  6.  
  7.     int numMoved = size - index - 1; 
  8.     if (numMoved > 0) 
  9.         System.arraycopy(elementData, index+1, elementData, index
  10.                          numMoved); 
  11.     elementData[--size] = null; // clear to let GC do its work 
  12.  
  13.     return oldValue; 

删除元素时,首先会判断索引是否大于ArrayList的大小,如果索引范围正确,则将索引位置的下一个元素赋值到索引位置,将ArrayList的大小-1,最后返回移除的元素。

「不用脑子的总结:删除后底层调用的依旧是System.arraycopy,而这个copy的过程是比较耗性能的,因此才说频繁增删的尽量别用ArrayList。」

ArrayList遍历删除

  1. @Override 
  2. public void forEach(Consumer<? super E> action) { 
  3.     Objects.requireNonNull(action); 
  4.     // 预设值了一个expectedModCount值 
  5.     final int expectedModCount = modCount; 
  6.     @SuppressWarnings("unchecked"
  7.     final E[] elementData = (E[]) this.elementData; 
  8.     final int size = this.size
  9.     // 遍历过程中拿出来判断 
  10.     for (int i=0; modCount == expectedModCount && i < size; i++) { 
  11.         action.accept(elementData[i]); 
  12.     } 
  13.     // 如果对不上则报错 
  14.     if (modCount != expectedModCount) { 
  15.         throw new ConcurrentModificationException(); 
  16.     } 
  1. public E remove(int index) {  
  2.     rangeCheck(index);  
  3.  // 修改了modCount  
  4.     modCount++;  
  5.     E oldValue = elementData(index);  
  6.   
  7.     int numMoved = size - index - 1;  
  8.     if (numMoved > 0)  
  9.         System.arraycopy(elementData, index+1, elementData, index,  
  10.                          numMoved);  
  11.     elementData[--size] = null; // clear to let GC do its work  
  12.   
  13.     return oldValue;  
  14. }  

从代码就可以看出来了,在遍历的时候会率先 预设值了一个expectedModCount值,然后再遍历拿出来判断,如果不一样了,则中断流程并且报错,而这个过程则涉及到了快速失败机制了,正常来说,ArrayList不允许遍历删除。

「不用脑子的总结:ArrayList通过预设值expectedModCount实现了快速失败机制,避免了多线程遍历删除或者增加,以及遍历过程中增删元素。」

集合的快速失败(fail-fast)

它是 Java 集合的一种错误检测机制,当多个线程对集合进行结构上的改变操作时,有可能会产生 fail-fast 机制。

迭代器在遍历时直接访问集合中的内容,并且在遍历过程中使用一个 modCount 变量。集合在被遍历期间如果内容发生变化,就会改变modCount的值。每当迭代器使用hashNext()/next()遍历下一个元素之前,都会检测modCount变量是否为expectedmodCount值,是的话就返回遍历;否则抛出异常,终止遍历。

注意:这里异常的抛出条件是检测到 modCount!=expectedmodCount 这个条件。如果集合发生变化时修改modCount值刚好又设置为了expectedmodCount值,则异常不会抛出。因此,不能依赖于这个异常是否抛出而进行并发操作的编程,这个异常只建议用于检测并发修改的bug。

场景:java.util包下的集合类都是快速失败的,不能在多线程下发生并发修改(迭代过程中被修改)。

「不用脑子的总结:我们日常看到的Concurrent Modification Exception,其实就是触发了快速失败机制的表现,做法也很简单:在遍历的时候给你给modCount设置个备份expectedModCount,如果有多线程在搞,那么必定会导致modCount被改,那么就容易了,每次遍历的时候都检测下modCount变量是否为expectedModCount就可以了,如果不是意味着被改了,那我就不管,我就要报错。」

集合的安全失败(fail-safe)

采用安全失败机制的集合容器,在遍历时不是直接在集合内容上访问的,而是先复制原有集合内容,在拷贝的集合上进行遍历。

原理:由于迭代时是对原集合的拷贝进行遍历,所以在遍历过程中对原集合所作的修改并不能被迭代器检测到,所以不会触发Concurrent Modification Exception。

缺点:基于拷贝内容的优点是避免了Concurrent Modification Exception,但同样地,迭代器并不能访问到修改后的内容,即:迭代器遍历的是开始遍历那一刻拿到的集合拷贝,在遍历期间原集合发生的修改迭代器是不知道的。

场景:java.util.concurrent包下的容器都是安全失败,可以在多线程下并发使用,并发修改。

「不用记忆的总结:那么为啥并发容器的时候不怕呢?简单,因为采用了安全失败机制,在遍历的时候直接拷贝了一份出来,这样就不会触发了。」

使用ArrayList的subList()需要注意的地方

  1. public List<E> subList(int fromIndex, int toIndex) { 
  2.         subListRangeCheck(fromIndex, toIndex, size); 
  3.         return new SubList(this, 0, fromIndex, toIndex); 
  1. SubList(AbstractList<E> parent,int offset,int fromIndex,int toIndex) { 
  2.             this.parent = parent; 
  3.             this.parentOffset = fromIndex; 
  4.             this.offset = offset + fromIndex; 
  5.             this.size = toIndex - fromIndex; 
  6.             this.modCount = ArrayList.this.modCount; 

subList()返回结果不可强制转为ArrayList类型,因为该方法实质是创建一个内部类SubList实例,这个SubList是AbstractList的实现类,并不继承于ArrayList。

通过上面源码可以看出,通过parent属性指定父类并直接引用了原有的List,并返回该父类的部分视图,只是指定了他要使用的元素的范围fromIndex(包含),endIndex(不包含)。

那么,如果对其原有或者子List做数据性修改,则会互相影响。如果对原有List进行结构性修改,则会踩坑Fast-fail,报错会抛出异常ConcurrentModification Exception。

ArrayList迭代器

看下迭代器的遍历和删除相关的源码

  1. public boolean hasNext() { 
  2.     return cursor != size
  3.  
  4. @SuppressWarnings("unchecked"
  5. public E next() { 
  6.     // 同样判断modCount != expectedModCount,不同则报错 
  7.     checkForComodification(); 
  8.     int i = cursor
  9.     if (i >= size
  10.         throw new NoSuchElementException(); 
  11.     Object[] elementData = ArrayList.this.elementData; 
  12.     if (i >= elementData.length) 
  13.         throw new ConcurrentModificationException(); 
  14.     cursor = i + 1; 
  15.     return (E) elementData[lastRet = i]; 
  16.  
  17. public void remove() { 
  18.     if (lastRet < 0) 
  19.         throw new IllegalStateException(); 
  20.     checkForComodification(); 
  21.  
  22.     try { 
  23.         ArrayList.this.remove(lastRet); 
  24.         cursor = lastRet; 
  25.         lastRet = -1; 
  26.         // 这里删除后会重新复制一次 
  27.         expectedModCount = modCount; 
  28.     } catch (IndexOutOfBoundsException ex) { 
  29.         throw new ConcurrentModificationException(); 
  30.     } 

通过代码我们也可以看出ArrayList的迭代器是支持遍历删除的,因为在删除后会重新赋一次值给expectedModCount。

ArrayList和LinkedList的优劣

其实就是数组和链表的优劣势,ArrayList优点,支持随机访问,get(i)的时间复杂度为O(1),而缺点就是需要扩容,要复制数组,而且内部插入数据需要移动数据,插入删除的性能差;

对于LinkedList来说,优点就是容量理论上来说是无限,不存在扩容,而且可以很方便的插入和删除数据(性能损失在查找),而缺点就是不能随机访问,get(i)需要遍历。 

貌似就是反过来的,所以在实际开发中也很容易区别,看是查找频繁、还是增删频繁,如果是查找频繁就用ArrayList,如果增删频繁就用LinkedList即可。

 

责任编辑:武晓燕 来源: 稀饭下雪
相关推荐

2021-11-29 05:37:24

Windows Def操作系统微软

2015-07-15 13:00:31

英特尔开源

2023-10-31 12:29:25

模型训练

2018-06-27 14:23:38

机器学习人工智能入门方法

2017-12-12 11:09:39

显卡散热CPU

2024-01-04 12:33:17

ChatGPTAI视频

2021-02-21 17:14:27

程序员技能开发者

2018-05-02 09:38:02

程序员代码互联网

2020-06-08 08:38:24

可执行文件文件字符

2021-08-31 09:35:01

TCPIP漏洞

2023-08-10 08:00:00

2021-07-21 05:38:20

中国联通携号转网移动

2019-08-19 09:21:36

程序员Bug代码

2021-01-27 18:13:35

日志nginx信息

2019-04-12 09:24:46

Spring Clou服务注册

2019-10-12 08:53:26

Redis多线程版本

2019-04-28 14:14:48

爬虫网络特价机票

2017-12-26 15:41:26

2018-01-26 23:23:23

JDBC MySQL数据库

2019-12-09 10:13:20

HashMap选择容量
点赞
收藏

51CTO技术栈公众号