引言

  从JDK1.5起,增加了加强型的for循环语法,也被称为 “for-Each 循环”。加强型循环在操作数组与集合方面增加了很大的方便性。那么,加强型for循环是怎么解析的呢?同时,这是不是意味着基本for循环就会被取代呢?

语法:

for(var item:items){//var 代表各钟类型
//相关操作
}

一、数组中的 for-Each 循环

我们先来看一下数组中的 for-Each 循环的使用;

String str[]= new String[]{"1","2","3"};

    //普通for循环
for(int i=0;i<str.length;i++){
String item = str[i];
item += "str";
System.out.println(item);
} //加强型for循环
for(String item:str){
item += "str";
System.out.println(item);
}

  通过比较上面例子中的两种类型的for循环,可以看出,for-Each 循环编写起来更加简单,更加方便程序员。因此,在程序中,应该多使用加强型循环。

回答一下上面提出的两个问题:

  1. 编译器是怎么处理数组中的for-Each循环的?

      事实上,在数组中的 for-Each 最终会被编译器处理成一个普通的for循环,也就是说 for-Each循环是完全与普通for循环等价的,没有任何特殊的命令。

    可以通过反编译来验证,很简单,此处不再多说。

  2. 在数组中,for-Each 循环能否完全替代普通for循环

      答案是否定的。虽然for-Each 写起来方便,但也有以下几个局限性:

  • 只能对元素进行顺序的访问;
  • 只能访问数组或集合中的所有元素;
  • 循环中没有当前的索引,无法对指定的元素操作。如更换当前索引位置的元素。

二、集合中的 for-Each循环

  数组的加强型的for-Each循环很简单,我们再来看一下集合中的for-Each 循环又是怎么样的。我们都知道集合中的遍历都是通过迭代(iterator)完成的。也许有人说,也可以按照下面的方式来遍历集合,不一定非要使用迭代:

List<String> list = new LinkedList<String>();
list.add("a");
list.add("b");
list.add("c"); for(int i=0;i<list.size();i++){
String item = list.get(i);
System.out.println(item);
}

  然而,这种方式对于基于链表实现的List来说,是比较耗性能的,因为get(int i)方法包含了一个循环,而且这个循环就是迭代遍历一次List,直到遇到第i个元素,才停止循环,返回第i个元素。对于数量小,遍历不频繁的List来说,开销可以忽略。否则,开销将不容忽视。

所以,正确集合遍历是使用迭代器Iterator来遍历的:

List<String> list = new LinkedList<String>();
list.add("a");
list.add("b");
list.add("c"); //获取集合的迭代器
Iterator<String> itor = list.iterator();
//集合的普通for循环
for(;itor.hasNext();){//相当于 while(itor.hasNext())
String item = itor.next();
System.out.println(item);
}

再看看对应的for-Each循环的例子:

    List<String> list = new LinkedList<String>();
list.add("a");
list.add("b");
list.add("c"); for(String item:list){//for-Each
System.out.println(item);
}

可以看出,for-Each循环比普通for循环要简洁很多。我们依旧回答上面的两个问题:

1. 编译器是如何处理 集合中的for-Each循环的?

public static void main(String args[])
{
List list = new LinkedList();
list.add("aa");
list.add("bb");
for(String item:list)
{
if("bb".equals(item))
list.add("cc");
} }

我们看一下上面例子的 反编译代码:

public static void main(String args[])
{
List list = new LinkedList();
list.add("aa");
list.add("bb");
for(Iterator iterator = list.iterator(); iterator.hasNext();)
{
String item = (String)iterator.next();
if("bb".equals(item))
list.add("cc");
} }

  与数组类似,编译器最终也就是将集合中的for-Each循环处理成集合的普通for循环。 而集合的Collection接口通过扩展Iterable接口来提供iterator()方。那么我们换一个角度,是不是只要实现 Iterable接口,提供iterator()方法,也可以使用 for-Each循环呢?来看个例子:

class  MyList<T> implements Iterable<T>{

	private ArrayList<T> list = new ArrayList<>();

	public void addId(T id){
list.add(id);
} public boolean removeId(T id){ return list.remove(id);
} @Override
public Iterator<T> iterator() {//扩展自Iterable接口 //为了简单起见,就直接使用已有的迭代器
return list.iterator();
} public static void main(String[] args) { MyList<String> myList = new MyList<>();
myList.addId("666999");
myList.addId("973219");
//for-Each
for(String item:myList){
System.out.println(item);
}
}
}

  上面的例子编译通过,并且运行无误。所以,只要实现了Iterable接口的类,都可以使用for-Each循环来遍历。

集合迭代的陷阱

  集合循环遍历时所使用的迭代器Iterator有一个要求:在迭代的过程中,除了使用迭代器(如:Iterator.remove()方法)对集合增删元素外,是不允许直接对集合进行增删操作。否则将会抛出 ConcurrentModificationException异常。所以,由于集合的for-Each循环本质上使用的还是Iterator来迭代,因此也要注意这个陷阱。for-Each循环很隐蔽地使用了Iterator,导致程序员很容易忽略掉这个细节,所以一定要注意。看下面的例子,for-Each循环中修改了集合。

public static void main(String[] args) {
List<String> list = new LinkedList<>();
list.add("aa");
list.add("bb"); for (String item : list) {//for-Each
if ("bb".equals(item)) {
list.add("cc"); //直接操作list
}
}
}

运行抛出异常:

  上面仅仅是 单线程 下的情况,如果你有并发编程的基础的话,就会知道:在 多线程 的环境中,线程是交替运行的(时间片轮转调度)。这就意味着,如果有两个线程A、B,线程A对集合使用Iterator迭代遍历,线程B则对集合进行增删操作。线程A、B一旦交替运行,就会出现在迭代的同时对集合增删的效果,也会抛出异常。解决办法就是加锁变成原子操作,多线程在这里不是本文重点,不多说了。

2. 集合中的for-Each循环能代替集合的普通for循环吗?

  同样也是不能的。集合中的for-Each循环的局限性与数组的for-Each循环是一样的。集合的for-Each循环是不能对集合进行增删操作、也不能获取索引。而集合的普通for循环可以使用的迭代器提供了对集合的增删方法(如:Iterator.removeListIterator.add()),获取索引的方法(如:ListIterator.nextIndex()ListIterator.previousIndex());

三、Iterator源码分析

  我们来分析一下Iterator源码,主要看看为什么在集合迭代时,修改集合可能会抛出ConcurrentModificationException异常。以ArrayList中实现的Iterator为例。

先来看一下ArrayList.iterator()方法,如下:

 public Iterator<E> iterator() {
return new Itr();
}

iterator()方法直接创建了一个类Itr的对象。那就接着看 Itr类的定义吧!发现Itr其实是ArrayList的内部类,实现了 Iterator 接口。

/**
* An optimized version of AbstractList.Itr
*/
private class Itr implements Iterator<E> {
int cursor; // 当前的索引值,index of next element to return
int lastRet = -1; // index of last element returned; -1 if no such
int expectedModCount = modCount; public boolean hasNext() {
return cursor != size;
} @SuppressWarnings("unchecked")
public E next() {
checkForComodification();
int i = cursor;
if (i >= size)
throw new NoSuchElementException();
//ArrayList的底层数组
Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length)
throw new ConcurrentModificationException();
cursor = i + 1;
return (E) elementData[lastRet = i];
} public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification(); try {
ArrayList.this.remove(lastRet);
cursor = lastRet;
lastRet = -1;
//再次更新 expectedModCount
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
} @Override
@SuppressWarnings("unchecked")
public void forEachRemaining(Consumer<? super E> consumer) {
Objects.requireNonNull(consumer);
final int size = ArrayList.this.size;
int i = cursor;
if (i >= size) {
return;
}
final Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length) {
throw new ConcurrentModificationException();
}
while (i != size && modCount == expectedModCount) {
consumer.accept((E) elementData[i++]);
}
// update once at end of iteration to reduce heap write traffic
cursor = i;
lastRet = i - 1;
checkForComodification();
} final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}

  ArrayList.this.elementData是ArrayList的底层数组,上面这些方法都很简单,都是对ArrayList.this.elementData这个底层数组进行操作。

  重点看一下checkForComodification()方法,这个方法就是用来抛出 ConcurrentModificationException异常,这个方法也很简单,就是判断modCountexpectedModCount是否相等。modCount存储的AarryList中的元素个数。而expectedModCount则是对象创建时将modCount的值赋给它,也就是说expectedModCount存储的是迭代器创建时元素的个数。那么checkForComodification()方法其实在比较迭代期间,ArrayList元素的个数 是否发生了改变,如果改变了,就抛出异常。注意一下,expectedModCount除了在声明时赋值外,也在remove()方法中更新了一次。

总结

  • 无论是在数组中还是在集合中,for-Each加强型for循环都是它们各自的普通for循环的一种“简写方式”,即两者意思上是等价的,但前者方便简单,建议多使用。
  • for-Each循环不能完全代替普通for循环,因为for-Each有一定的局限性。
  • for-Each循环只能用于 数组、Iterable类型(包括集合)。
  • 集合中的for-Each循环本质上使用了Ierator迭代器,所以要注意Itrator迭代陷阱(单线程和多线程都有问题)。

java基础(三) 加强型for循环与Iterator的更多相关文章

  1. Java 基础三、接口与内部类

    1.   在Java程序语言中,接口是对类的一种描述.例如Arrays类中sort方法声明可以对对象进行排序,但前提是对象所属的类必须实现Comparable接口. public interface ...

  2. Java面试题总结之Java基础(三)

    1.JAVA 语言如何进行异常处理,关键字:throws,throw,try,catch,finally分别代表什么意义?在try 块中可以抛出异常吗? 答:Java 通过面向对象的方法进行异常处理, ...

  3. java基础(三)

    1.枚举类,使用enum定义的枚举类默认继承java.lang.Enum,而不是Object类.枚举类的所有实例必须在枚举类中显示列出,否则这个枚举类永远都不能产生实例.相关内容较多,需要后续继续跟进 ...

  4. java基础三种循环的使用及区别

    摘要:Java新人初学时自己的一些理解,大神们路过勿喷,有什么说的不对不足的地方希望能给予指点指点,如果觉得可以的话,希望可以点一个赞,嘿嘿,在这里先谢了.在这里我主要说的是初学时用到的Java三个循 ...

  5. java 基础三

    1 运算符 1.1  比较运算符 比较运算符的结果都是boolean类型,也即是要么是true,要么是false. 比较运算符"=="不能写成"=". > ...

  6. Java基础(三)-final关键字分析

    今天来谈谈final关键字的作用, 虽然有很多博文关于final进行了很深的研究,但还是要去记录下谈谈自己的见解加深下印象.下面直接进入主题: 一.final关键字的作用 1.被final修饰的类不能 ...

  7. java基础(三)-----java的三大特性之多态

    面向对象编程有三大特性:封装.继承.多态. 封装隐藏了类的内部实现机制,可以在不影响使用的情况下改变类的内部结构,同时也保护了数据.对外界而已它的内部细节是隐藏的,暴露给外界的只是它的访问方法. 继承 ...

  8. java基础(三):反射、反序列化破解单列模式和解决方式

    单例模式指的是一个类只有一个对象,通过一些措施达到达到这个目的.但是反射和反序列化可以获得多个不同的对象. 先简单的认识一下单例模式 一:单例模式 通过私有构造器,声明一个该类的静态对象成员,提供一个 ...

  9. Java基础三(Scanner键盘输入、Random随机数、流程控制语句)

    1.引用类型变量的创建及使用2.流程控制语句之选择语句3.流程控制语句之循环语句4.循环高级 ###01创建引用类型变量公式 * A: 创建引用类型变量公式 * a: 我们要学的Scanner类是属于 ...

随机推荐

  1. Monkey捕获Crash原理

    Android的RuntimeInit.commonInit中会设置UncaughtHandler ActivityManagerService(AMS)在执行handleApplicationCra ...

  2. (转) centos7下创建mysql5.6多实例

    原文:http://blog.csdn.net/a1010256340/article/details/77483504 一.mysql安装目录说明mysql5.6以二进制安装包安装在/data/my ...

  3. Spring Security构建Rest服务-0102-Spring Social开发第三方登录之qq登录

    图一 基于SpringSocial实现qq登录,要走一个OAuth流程,拿到服务提供商qq返回的用户信息. 由上篇介绍的可知,用户信息被封装在了Connection里,所以最终要拿到Connectio ...

  4. javascript中函数声明和函数表达式的区别 分类: JavaScript 2015-05-07 21:41 897人阅读 评论(0) 收藏

    1.js中函数表达式的定义 表达式(expression)JavaScript中的一个短语,javascript会将其计算(evaluate)出一个结果.程序中的常量是一个最简单的表达式.变量名也是一 ...

  5. 转载:Spring学习总结

    地址:http://www.cnblogs.com/best/tag/Spring/

  6. Android 开发工具类 12_PullXmlTools

    xml 格式数据 <?xml version="1.0" encoding="UTF-8"?> <user-list> <user ...

  7. Google Guava--基础工具用法

    Optional 优雅的解决Null(java 8 提供了Optional类) Guava用Optional表示可能为null的T类型引用.一个Optional实例可能包含非null的引用(我们称之为 ...

  8. 白月黑羽Python在线教程

    推荐白月黑羽Python在线教程 白月黑羽 站在初学者的角度为大家安排了Python学习教程,帮助大家迅速掌握程序开发技能. http://www.python3.vip/doc/tutorial/p ...

  9. 容器挂载volume出现“Permission denied”的问题定位解决

    使用如下系统(centos)运行容器后,在容器内的挂载目录内执行ls命令出现了“Permission denied”的错误 Linux localhost.localdomain 3.10.0-862 ...

  10. koa2开发入门

    一.koa2入门 1.创建koa2工程 首先,我们创建一个目录hello-koa并作为工程目录用VS Code打开.然后,我们创建app.js,输入以下代码: // 导入koa,和koa 1.x不同, ...