迭代器笔试题,居然难倒很多人

开发 前端
有位小朋友最近正在为年后换工作做准备,但是遇到一个问题,觉得很不可思议的一道笔试题。然后我把这道题发到技术群里,发现很多人居然不知道,很多都是连蒙带猜的说。感觉很有必要写一篇文章来说道说道。

[[379497]]

有位小朋友最近正在为年后换工作做准备,但是遇到一个问题,觉得很不可思议的一道笔试题。然后我把这道题发到技术群里,发现很多人居然不知道,很多都是连蒙带猜的说。感觉很有必要写一篇文章来说道说道。

奇怪的笔试题阅读下面这段代码,请写出这段代码的输出内容:

  1. import java.util.ArrayList; 
  2. import java.util.Iterator; 
  3. import java.util.*; 
  4.  
  5. public class Test { 
  6.     public static void main(String[] args) { 
  7.  
  8.         List<String> list = new ArrayList<>(); 
  9.         list.add("1"); 
  10.         list.add("2"); 
  11.         list.add("3"); 
  12.         Iterator iterator = list.iterator(); 
  13.         while (iterator.hasNext()) { 
  14.             String str = (String) iterator.next(); 
  15.             if (str.equals("2")) { 
  16.                 iterator.remove(); 
  17.             } 
  18.         } 
  19.         while (iterator.hasNext()) { 
  20.             System.out.println(iterator.next()); 
  21.         } 
  22.         System.out.println("4"); 
  23.     } 

他写出来的答案是:

奇怪的是,你把这道题目发给你身边人,让他们回答这道面试题输出结果是什么,说这个结果的人非常多。不行你试试。

 

答案明显不对,因为在第一个while里的 iterator.hasNext()==false后才会到第二个while里来,同一个Iterator对象,前面调一次iterator.hasNext()==false,再判断一次结果不还是一样吗?,

所以第二个while判断为false,也就不会再去遍历iterator了,由此可知本体答案是:4。

下面我们来分析一下为什么是具体底层是怎么实现的。

这里的Iterator是什么?

  • 迭代器是一种模式、详细可见其设计模式,可以使得序列类型的数据结构的遍历行为与被遍历的对象分离,即我们无需关心该序列的底层结构是什么样子的。只要拿到这个对象,使用迭代器就可以遍历这个对象的内部
  • Iterable 实现这个接口的集合对象支持迭代,是可以迭代的。实现了这个可以配合foreach使用~
  • Iterator 迭代器,提供迭代机制的对象,具体如何迭代是这个Iterator接口规范的。

Iterator说明

  1. public interface Iterator<E> {  
  2.     //每次next之前,先调用此方法探测是否迭代到终点 
  3.     boolean hasNext(); 
  4.     //返回当前迭代元素 ,同时,迭代游标后移 
  5.     E next();  
  6.     /*删除最近一次已近迭代出出去的那个元素。 
  7.      只有当next执行完后,才能调用remove函数。 
  8.      比如你要删除第一个元素,不能直接调用 remove()   而要先next一下( ); 
  9.      在没有先调用next 就调用remove方法是会抛出异常的。 
  10.      这个和MySQL中的ResultSet很类似 
  11.     */ 
  12.     default void remove() { 
  13.         throw new UnsupportedOperationException("remove"); 
  14.     }  
  15.     default void forEachRemaining(Consumer<? super E> action) { 
  16.         Objects.requireNonNull(action); 
  17.         while (hasNext()) 
  18.             action.accept(next()); 
  19.     } 

这里的实现类是ArrayList的内部类Itr。

  1. private class Itr implements Iterator<E> { 
  2.         int cursor;       // index of next element to return 
  3.         int lastRet = -1; // index of last element returned; -1 if no such 
  4.         //modCountshi ArrayList中的属性,当添加或删除的时候moCount值会增加或者减少 
  5.         //这里主要是给fail-fast使用,避免一遍在遍历,一遍正在修改导致数据出错 
  6.         //此列表在结构上被修改的次数。结构修改是指改变结构尺寸的修改列表, 
  7.         //或者以这样的方式对其进行扰动,进步可能会产生错误的结果。 
  8.         int expectedModCount = modCount; 
  9.          
  10.         public boolean hasNext() { 
  11.             //cursor初始值为0,没掉一次next方法就+1 
  12.             //size是ArrayList的大小 
  13.             return cursor != size
  14.         } 
  15.  
  16.         @SuppressWarnings("unchecked"
  17.         public E next() { 
  18.             checkForComodification(); 
  19.             int i = cursor
  20.             if (i >= size
  21.                 throw new NoSuchElementException(); 
  22.             //把ArrayList中的数组赋给elementData 
  23.             Object[] elementData = ArrayList.this.elementData; 
  24.             if (i >= elementData.length) 
  25.                 throw new ConcurrentModificationException(); 
  26.             //每调用一次next方法,游标就加1 
  27.             //cursor=lastRet+1 
  28.             cursor = i + 1; 
  29.             //返回ArrayList中的元素 
  30.             return (E) elementData[lastRet = i]; 
  31.         } 
  32.  
  33.         public void remove() { 
  34.             if (lastRet < 0) 
  35.                 throw new IllegalStateException(); 
  36.             checkForComodification(); 
  37.  
  38.             try { 
  39.                 //调用ArrayList中remove方法,溢出该元素 
  40.                 ArrayList.this.remove(lastRet); 
  41.                 //cursor=lastRet+1, 
  42.                 //所以此时相当于cursor=cursor-1 
  43.                 cursor = lastRet; 
  44.                 lastRet = -1; 
  45.                 expectedModCount = modCount; 
  46.             } catch (IndexOutOfBoundsException ex) { 
  47.                 throw new ConcurrentModificationException(); 
  48.             } 
  49.         } 
  50.         final void checkForComodification() { 
  51.             if (modCount != expectedModCount) 
  52.                 throw new ConcurrentModificationException(); 
  53.         } 

再回到上面题目中:

第一个iterator.hasNext()

  • 第1次循环hasNext方法中:cursor==0, size==3,所以cursor != size返回true。
  • next方法中:cursor=0+1。返回"1"。

第2次循环

  • hasNext方法中:cursor==1, size==3,所以cursor != size返回true。
  • next方法中:cursor=1+1。返回"2"。
  • remove方法中:cursor==cursor-1==2-1=1,把ArrayList中的"2"给删除了,所以size==2。

第3次循环

  • hasNext方法中:cursor==1, size==2,那么cursor != size返回true。
  • next方法中:cursor=1+1==2;返回"3"。

第4次循环

  • hasNext方法中:cursor==2, size==2,那么cursor != size返回false。

第二个iterator.hasNext()

hasNext方法中:cursor==2, size==2,所以cursor != size返回false。

所以,最后只输出"4",即答案为4.

Iterator与泛型搭配

  • Iterator对集合类中的任何一个实现类,都可以返回这样一个Iterator对象。可以适用于任何一个类。
  • 因为集合类(List和Set等)可以装入的对象的类型是不确定的,从集合中取出时都是Object类型,用时都需要进行强制转化,这样会很麻烦,用上泛型,就是提前告诉集合确定要装入集合的类型,这样就可以直接使用而不用显示类型转换.非常方便.

foreach和Iterator的关系

  • for each以用来处理集合中的每个元素而不用考虑集合定下标。就是为了让用Iterator简单。但是删除的时候,区别就是在remove,循环中调用集合remove会导致原集合变化导致错误,而应该用迭代器的remove方法。

使用for循环还是迭代器Iterator对比

  • 采用ArrayList对随机访问比较快,而for循环中的get()方法,采用的即是随机访问的方法,因此在ArrayList里,for循环较快
  • 采用LinkedList则是顺序访问比较快,iterator中的next()方法,采用的即是顺序访问的方法,因此在LinkedList里,使用iterator较快
  • 从数据结构角度分析,for循环适合访问顺序结构,可以根据下标快速获取指定元素.而Iterator 适合访问链式结构,因为迭代器是通过next()和Pre()来定位的.可以访问没有顺序的集合.
  • 而使用 Iterator 的好处在于可以使用相同方式去遍历集合中元素,而不用考虑集合类的内部实现(只要它实现了 java.lang.Iterable 接口),如果使用 Iterator 来遍历集合中元素,一旦不再使用 List 转而使用 Set 来组织数据,那遍历元素的代码不用做任何修改,如果使用 for 来遍历,那所有遍历此集合的算法都得做相应调整,因为List有序,Set无序,结构不同,他们的访问算法也不一样.(还是说明了一点遍历和集合本身分离了)。

总结

  • 迭代出来的元素都是原来集合元素的拷贝。
  • Java集合中保存的元素实质是对象的引用,而非对象本身。
  • 迭代出的对象也是引用的拷贝,结果还是引用。那么如果集合中保存的元素是可变类型的,那么可以通过迭代出的元素修改原集合中的对象。

本文转载自微信公众号「Java后端技术全栈」,可以通过以下二维码关注。转载本文请联系Java后端技术全栈公众号。

 

责任编辑:武晓燕 来源: Java后端技术全栈
相关推荐

2018-02-13 14:48:17

戴尔

2022-01-05 23:34:02

显示器滤蓝光LED

2022-02-06 00:07:19

互联网失业职业

2022-07-06 10:33:39

技术债务CIO

2019-12-09 10:02:41

泛型ypeScript前端

2017-12-13 15:57:12

2020-06-04 18:34:15

路由器耗电硬件

2021-06-24 09:08:34

Java代码泛型

2019-08-21 08:24:34

技术过滤器代码

2020-06-29 08:28:36

v-for 解构函数

2014-05-09 15:29:21

2020-11-16 11:24:00

Spring AOP数据库

2021-01-15 05:39:13

HashMapHashTableTreeMap

2020-06-08 19:16:52

大数据IT技术

2021-02-22 13:14:00

计算机编程技术

2019-08-08 16:00:08

HTTPGETPOST

2021-09-21 10:33:56

人工智能科学技术

2021-09-21 15:56:00

iPhone 13苹果双十一

2020-02-28 10:10:07

开源技术 工具

2021-08-27 10:03:12

人工智能AI
点赞
收藏

51CTO技术栈公众号