学步园

前言:增强For循环示例:

     //循环数组
        int str[] = {22,454,676,7,99};   
        for(int i : str){   
            System.out.println(i);   
        }   
        //循环集合
        Collection c = new ArrayList();   
        String a = "sldjf";   
        String b = "lkfgjl";   
        c.add(a);   
        c.add(b);   
        for(Object i : c){   
            System.out.println(i);   
        }   

for(类型 自定义值 :  集合){

//类型必须是集合里的类型

}

如果是简单的输出数组或者集合的对象，这个增强版的还是比较方便的，但是如果在for循环里面要处理一些特殊情况的话，这种可能就不行了。

下面进入正题,下面的资料摘自http://blog.csdn.net/yinzhuo1/article/details/7302351:

1.增强for循环和iterator遍历的效果是一样的
也就是说增强for循环的内部也就是调用iteratoer实现的(可以查看编译后的文件)，
但是增强for循环有些缺点,
例如不能在增强循环里动态的删除集合内容。不能获取下标等。

2.ArrayList由于使用数组实现，因此下标明确，最好使用普通循环。

3.而对于 LinkedList 由于获取一个元素，要从头开始向后找，因此建议使用 增强for循环，也就是iterator。
下面的例子可以证明

A:为ArrayList的时候一切正常,list为五百万,用普通for循环时间为:94毫秒,用增强for循环时间为:234毫秒.因为ArrayList是使用数组实现,下标明确,因此使用普通for循环更快更好.

B:而使用LinkedList的时候,list为五百万的时候,普通for循环会一直处理下去,因为时间太长,你要等很久,最后可能会内存溢出.因此List改为5000,然后可以看到他们使用的毫秒数如下:
for + get(i)方法: 1223
Iterator(foreach)方法:2

因此LinkedList循环的时候必须使用增强for循环.

package org.credo.connection;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class Test {
	public static void main(String[] args) {
		// 为ArrayList的时候一切正常,换为LinkedList后,运行会很慢,最后报内存溢出异常.
		List<Integer> list = new ArrayList<Integer>();
		for (int i = 0; i < 5000000; i++) {
			//每次循环都往list中赋一个对象.
			list.add(11);
		}
		
		
		//下面是普通for循环的使用
		long start = System.currentTimeMillis();
		int size = list.size();
		int c1 = 1;
		for (int i = 0; i < size; i++) {
			//每次循环都从list中读取一个对象.用linkedList的时候应该用for (int c2 : list)
			//c1 = list.get(i);
		}
		System.out.println("System.currentTimeMillis():"
				+ System.currentTimeMillis());
		System.out.println("for + get(i)方法: "
				+ (System.currentTimeMillis() - start));
		
		
		
		//下面是增强for循环,也就是Iterator(foreach)方法
		long start2 = System.currentTimeMillis();
		for (int c2 : list)
		{
		}
		System.out.println("Iterator(foreach)方法:"
				+ (System.currentTimeMillis() - start2));
		
		//while循环
		int c3=1;
		long start3=System.currentTimeMillis();
		while(c3<list.size()){
			c3++;
		}
		System.out.println("While方法:"
				+ (System.currentTimeMillis() - start3));
	}
}

下面是结果图:

用LinkedList的时间如下:

用arraylist的时间如下:

擦,以前的代码里,for正常循环里,我进行赋值操作了,所以内存溢出.正常貌似还是一般for循环好点,搞不明白,反正linkedList用foreach循环就对了..官方那么说的.虽然我结论貌似不一样.

4.多线程

//for (Block b : __blocks) {
//b.onDraw(canvas);
//}
//Iterator<Block> it = __blocks.iterator();
//while(it.hasNext()){
//Block b = it.next();
//b.onDraw(canvas);
//}
for(int i = 0; i < __blocks.size(); i++){
__blocks.get(i).onDraw(canvas);
}

 另外外一个线程动态的改变__blocks的大小    
 只有普通for循环不报错，其他通过迭代器实现的是先有一个拷贝，所以真正得到时 ，会报并发修改错误。

5单线程

在单线程中  增强for不能动态删除元素，用Iterator能实现。
一下是示例代码

Map<String, String> map = new HashMap<String, String>();
map.put("1", "a1");
map.put("2", "a2");
map.put("3", "a3");
map.put("4", "a4");
map.put("5", "a5");


for (String key : map.keySet()) {
if ("a2".equals(map.get(key))) {
map.remove(key);
}
}
System.out.println(map.size());


List<String> list = new ArrayList<String>();
list.add("a1");
list.add("a2");
list.add("a3");
list.add("a4");
list.add("a5");


Iterator<String> it = list.iterator();
while (it.hasNext()) {
String v = it.next();
if ("a2".equals(v)) {
it.remove();
}
}


for (String v : list) {
System.out.println(v);
}
}