Java中的forin语句

forin的原理

forin语句是JDK5版本的新特性，在此之前，遍历数组或集合的方法有两种：通过下标遍历和通过迭代器遍历。先举个例子：

@Test
public void demo() {
    String arr[] = { "abc", "def", "opq" };
    for (int i = 0; i < arr.length; i++) {//通过下标遍历数组
        System.out.println(arr[i]);
    }
    System.out.println("----------");
    List<String> list = new ArrayList<String>();
    list.add("abc");
    list.add("def");
    list.add("opq");
    Iterator<String> iterator = list.iterator();
    while (iterator.hasNext()) {//通过迭代器遍历集合
        System.out.println(iterator.next());
    }
}

用JUnit进行单体测试，两种方法的输出结果是一样的：

demo()运行效果

JDK5以后引入了forin语句，目的是为了简化迭代器遍历，其本质仍然是迭代器遍历。forin语句的写法很简单：

for(数据类型 对象名 : 数组或集合名){
    ...
}

这里的数据类型是数组或集合中的数据类型，接着声明一个该数据类型的对象，用于代替数组或集合中的每一个元素（因此forin语句又称为foreach语句），最后便是对该对象也就是数组或集合中元素的操作了。
修改上面的代码，用forin语句遍历刚才的数组和集合：

System.out.println("----------");
for (String s1 : arr) {
    System.out.println(s1);
}
System.out.println("----------");
for (String s2 : list) {
    System.out.println(s2);
}

用JUnit进行单体测试，输出的结果与之前相同：

demo()运行效果

需要注意的是，通过forin语句遍历和通过迭代器遍历是完全等价的。另外，在使用Eclipse进行编程的时候，可以使用alt+/进行快捷输入生成下标遍历的for循环语句或forin语句，十分方便。
下面讲一个关于数组内存的问题，在上面的代码中再添加一段：

System.out.println("----------");
for (String s3 : arr) {
    s3 = "rst";
}
System.out.println(arr[0]);

如果按照常规的思维去理解，数组中的三个元素应该都被修改为了rst，因此最后输出的结果也应全部为rst。然而并不是这样的，用JUnit进行单体测试：

demo()运行效果

结果很明显，输出的是abc、def、opq而非三个rst，也是说数组中的三个元素并没有被rst替换。要解释这个问题就要从Java中的内存讲起，在Java中，方法中的引用位于堆空间，而对象则实例化在栈空间。数组{ "abc", "def", "opq" }属于方法中的引用，因此存储在堆空间中，而s3和arr属于实例化的对象，则应存储在栈空间中。在String arr[] = { "abc", "def", "opq" };这句代码中，=的作用就是将栈空间中的arr指向堆空间中的数组，而forin语句的作用则是每循环一次就将堆空间中数组元素的值赋给栈空间中的s3，而这些元素的值实际上不会发生改变。因此遍历并输出数组所有元素得到的结果与之前完全一样。下图可以帮助理解这个问题：

数组内存

forin的实现

如果一个对象想使用forin语句进行遍历，则对象类必须满足两个条件：实现Iterable接口和实现Iterator方法。之所以ArrayList集合类能够实现forin语句遍历，就是因为其满足上述两个条件：

Collection接口继承Iterable接口

Collection接口实现Iterator方法

由于ArrayList集合类继承AbstractList类，AbstractList类继承AbstractCollection类，AbstractCollection类又实现Collection接口，因此ArrayList集合类间接地实现了Iterable接口和Iterator方法。
现在我们试着编写一个Phone类，然后让Phone类对象能够实现forin语句遍历：

public class Phone implements Iterable<String> {//实现Iterable接口
    String[] names = { "苹果", "三星", "华为", "小米", "魅族" };
    public Iterator<String> iterator() {//实现Iterator方法同时自定义迭代器
        Iterator<String> iterator = new MyIterator();
        return iterator;
    }
    class MyIterator implements Iterator<String> {
        int index = 0; 
        public boolean hasNext() {
            if (index >= names.length) { 
                return false;
            }
            return true;
        }
        public String next() {
            String name = names[index];
            index++;
            return name;
        }
        public void remove() {
        }
    }
}

创建新的方法用于测试：

@Test
public void demo1(){
    Phone phone = new Phone();//实例化Phone类对象
    for (String s : phone) {//forin语句遍历Phone类对象phone
        System.out.println(s);
    }
}

用JUnit进行测试，结果是正确的：

demo1()运行结果

forin删除元素

再创建一个方法，这次对集合的元素进行一些改动，然后用两种方法删除包含字符a的字符串。首先是通过下标遍历集合：

@Test
public void demo2(){
    List<String> list = new ArrayList<String>();
    list.add("abc");
    list.add("ade");
    list.add("afg");
    list.add("def");
    list.add("opq");
    for (int i = 0; i < list.size(); i++) {
        String s = list.get(i);
        if (s.contains("a")){
            list.remove(s);
        }
    }
    System.out.println(list);
}

这段代码看起来再正确不过，然而输出结果却是错误的：

demo2()运行效果

这是因为当删除完第一个字符串abc后，第二个字符串ade会自动成为第一个字符串，因此当下标变成1时，得到的字符串就不是ade而是afg了，字符串ade并没有被删除掉，便会出现错误的结果。
为了防止通过下标删除集合元素时产生类似的错误，每次删除完元素后应将下标减一，即i--。改正代码后再次测试，结果就正确了：

demo2()运行效果

接着是用forin语句遍历，很简单地想到代码应该为：

for (String s : list) {
    if(s.contains("a")){
        list.remove(s);
    }
}
System.out.println(list);

然而事与愿违，程序报错了，抛出了一个异常：

程序报错

这个异常为并发修改异常。我们将关注的焦点放在第三行错误信息上，可以发现是ArrayList类中Itr类（迭代器类）的next()方法出现了异常，查看方法的声明，会发现调用了checkForComodification()方法，继续查看声明：

checkForComodification()方法声明

这里出现了两个参数：modCount和expectedModCount，并且如果这两个参数不等，则会抛出并发修改异常。expectedModCount参数是集合的初始化长度，而modCount参数则是集合的当前长度。回到ArrayList类中Itr类的声明，会有这么一段代码：

集合长度初始化

也就是说，在集合初始化的时候，expectedModCount与modCount是相等的，但是一旦向集合中添加或者删除了元素，两者就不等了，也就会抛出异常。
要想解决抛出异常的问题，可以使用Itr类中的remove()方法，先查看方法的声明：

remove()方法声明

有一句代码十分关键：expectedModCount = modCount;。显然调用remove()方法能够将expectedModCount与modCount置为相等，因此这样能够避免程序抛出并发修改异常。
用集合迭代器的remove()方法删除集合的元素：

Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    String s = iterator.next();
    if (s.contains("a")) {
        iterator.remove();
    }
}
System.out.println(list);

用JUnit进行单体测试，结果自然是正确的：

demo2()运行效果

如果只需要删除集合中的一个元素例如删除字符串afg，这时候就可以使用集合的remove()方法进行删除，但前提是删除完之后必须用break语句跳出循环：

for (String s : list) {
    if (s.equals("afg")) {
        list.remove(s);
        break;
    }
}    
System.out.println(list);

demo2()运行效果

原理也很简单，还记得之前介绍过forin语句就是迭代器遍历吗？用break语句跳出循环使得迭代器无法调用next()方法，从而也不会抛出并发修改异常了。
还有一种方法，抛出异常是由集合自身性质所决定的，如果采用不会抛出这类异常的集合不就能解决问题了吗？JDK5版本引入了Copy-On-Write容器的概念，CopyOnWrite机制的理念就是：当我们往一个容器添加或删除元素的时候，不直接往当前容器添加或删除，而是先将当前容器进行Copy，复制出一个新的容器，然后新的容器里添加或删除元素，在这之后再将原容器的引用指向新的容器。目前有CopyOnWriteArrayList和CopyOnWriteArraySet两个实现类，因此我们可以采用CopyOnWriteArrayList类：

List<String> list = new CopyOnWriteArrayList<String>();
list.add("abc");
list.add("ade");
list.add("afg");
list.add("def");
list.add("opq");
for (String s : list) {
    if (s.contains("a")){
        list.remove(s);
    }
}
System.out.println(list);

用JUnit进行测试，结果是正确的：

demo2()运行效果