for（type element：array）{

System.out.println(array);

}



for（int i=0，i++.i<3）{

System.out.println(i);

}

上面两个for什么时候用第一个for，什么时候用第二个for

代码好乱！整理一下了。

当要遍历取出数组或者集合即容器里地元素是就用第一个
当要修改容器里的值 时 或一段代码要执行多次时用地2个
如  int[] nums={2,3,4,3}
for(int num:nums){
   System.out.println(num);
}


1到10的和
int sun=0;
for (int i=1;i<11;i++){
    sun+=i;
}


在数组里查找值为5的元素并修改为
for(int i=0;i<nums.length;i++){
if(nums==5){
  nums=6;
}
}
还有很多情况用地2种

第一个是高级for循环，用到普通数组和collection子类里。有局限性，括号里只能传参数不能定位
第二个是普通for循环，应用于各种状况，但是普通for的代码较长。
还有哥们你的普通for ()写错了 里面是; 不是，

第一种为普通的for循环
这种普通的for循环通常需要三个步骤即

你说的第一个是增强for循环，第二个是普通for循环。

增强型的for循环 优点主要体现在集合中，随便举个例子
比如对 set 的遍历
一般是迭代遍历：
Set<String> set = new HashSet<String>();
Iterator<String> it = set.iterator();
while (it.hasNext()) {
  String str = it.next();
  System.out.println(str);
}
for循环遍历：
for (String str : set) {
      System.out.println(str);
}
是不是简单些?

优点还体现在泛型 假如 set中存放的是Object

Set<Object> set = new HashSet<Object>();
for循环遍历：
for (Object obj: set) {
      if(obj instanceof Integer){
                int aa= (Integer)obj;
             }else if(obj instanceof String){
               String aa = (String)obj
             }
              ........
}
如果你用Iterator遍历，那就晕了
map list 也一样

唯一的缺点就是 在遍历 集合过程中，不能对集合本身进行操作
  for (String str : set) {
   set.remove(str);//错误！
  }



   

for循环有两种：
第一种为普通的for循环（你说的第2个例子）
    这种for循环通常需要三个步骤即 for（初始表达式；条件表达式；递增表达式）有时候递增表达式也可以省去，一般是在使用Iterator迭代时。这种for循环很常用。
第二种为增强的for循环（你说的第1个例子）
    这种for循环的内部是调用了Iterator实现的，和Iterator遍历效果是一样（你可以断点调试跟踪代码看看内部原理），优点是写法简便，缺点是不能再循环里动态的删除元素和获取元素下标。
拿数组和链表来区分记忆：  
1.ArrayList由于使用数组实现，因此下标明确，最好使用普通for循环。
2.而对于 LinkedList 由于获取一个元素，要从头开始向后找，因此建议使用增强for循环，也就是iterator。
看代码：

1. import java.util.ArrayList;
   
2. import java.util.LinkedList;
   
3. import java.util.List;
   
4. 
   
5. public class ForTest {
   
6. public static void main(String[] args) {
   
7. // List<Integer> list = new ArrayList<Integer>();
   
8. List<Integer> list = new LinkedList<Integer>();
   
9. for (int i = 0; i < 40000; i++) {
   
10. list.add(5);
    
11. }
    
12. int resutl = 0;
    
13. long start = System.currentTimeMillis();
    
14. //使用普通for循环
    
15. for (int i = 0; i < list.size(); i++) {
    
16. resutl = list.get(i);
    
17. }
    
18. System.out.println("普通循环使用了" + (System.currentTimeMillis() - start)
    
19. + "毫秒");
    
20. start = System.currentTimeMillis();
    
21. //使用增强for循环，这里什么也不做
    
22. for (int c2 : list) {
    
23. }
    
24. System.out.println("增强for循环使用了" + (System.currentTimeMillis() - start)
    
25. + "毫秒");
    
26. }
    
27. }
    

复制代码

输出结果为：

很明显使用增强for循环去迭代链表非常合适。
而如果将上面ArrayList的注释去掉，不用LinkedList则是使用普通for循环非常的合适。自己可以试试看哦!
为此我写了一篇日记，地址: http://bostonivy4me.blog.163.com/blog/static/191561331201232183218678/

图片传的有问题，不过点击后可以看清楚。