三种循环：普通for循环、高级for循环、迭代器有哪些区别和联系？！回答的好的有分哦！大家速度来！

用以下方式遍历数组（索引方式）：

1. for (int i = 0; i < a.length; i++) {     
   
2.     doSomething(a[i]);
   
3. }

复制代码

foreach循环，通过完全地隐藏迭代器和索引变量，避免了混乱和出错的可能。这种模式同时适用于集合和数组：

1. for(Element e : elements) {
   
2.     doSomething(e);
   
3. }

复制代码

增强for循环和iterator遍历的效果是一样的，也就说增强for循环的内部也就是调用iteratoer实现的，使用foreach的对象必须实现Iterator 接口。但是增强for循环有些缺点，例如不能在增强循环里动态的删除集合内容。不能获取下标等。
增强循环在简洁性和预防bug方面有着传统的for循环无法比拟的优势，要多说的是foreach效率和迭代器效率差不多。传统for循环效率要比增强for循环效率高，有些情况下我们应该尽可能地使用foreach循环。但：
1.如果要遍历集合，并删除选定的元素，就需要使用显势的迭代器，以便可以调用它的remove方法
2.如果需要遍历列表或者数组，并取代它部分或者全部的元素值，就需要列表迭代器或者数组索引，以便设定元素的值。

联系：
普通for循环、高级for循环、迭代器都是循环控制语句。
区别：
普通for循环必须指定初始值和终止条件，如果是用来遍历数组的话，不好控制容易发生下标溢出等问题，而且无法利用普通for语句来遍历集合。
迭代器主要应用于集合中，除了可以遍历集合外，还可以对集合进行操作，有删除等方法。
高级for循环是JDK1.5的新特性，必须有遍历目标，但不必指定上标和下标。它融合了普通for循环和迭代器，既可以对数组进行遍历，也可以对集合进行遍历。但是高级的for()循环只能实现查找不能删除元素。

普通for循环:通过定义循环开始变量，循环结束变量来确定循环次数，通过循环条件变化语句来改变循环变量。循环流程是：确定循环开始变量，判断是否符合循环结束条件，若不符合，执行循环代码，然后再执行循环条件变化语句，再判断是否符合循环结束条件，若符合，结束判断，不符合则继续。
高级for循环：只需要提供需要遍历的数组名或集合名，数组或集合类型，就能逐一遍历数组或者集合。
迭代器：通过判断是否还有下一个来构成循环，没有下一个对象的时候，自动结束循环。
区别：普通for循环需要三个条件才能完整的执行循环，对于集合和数组，必须有下标才能利用普通for循环来便利。一般来说，普通for循环的循环的循环次数是固定的。可以通过下标来遍历数组，也可以通过下标来修改数组。高级for循环，只需要一个数组或集合，就可以实现循环，局限性也很很大，只能遍历数组或者集合，对数组或集合的操作也有限。迭代器是专为集合设计的，弥补了高级for循环不能完全操作集合的问题。但是对于普通的循环则无能为力。联系：都是循环控制语句。

高级for用来遍历Collection或者数组，但是只能获取元素，不能对其进行操作。高级for有一个局限性，必须有被遍历的目标。相对于传统for，简化了代码。
一般遍历数组，还是建议使用传统for,因为可以定义脚标。
迭代器除了遍历，还可以进行remove集合中元素的动作，不过相对于高级for,代码块稍显复杂。

迭代运行里可以包含多个FOR循环，for循环方便于访问顺序存储的记录

格式：
普通for循环
for(; ; ; ){循环体}

高级for循环
for(数据类型 变量名：数组或者实现了Iterable接口的集合类){  }

迭代器：
while(iterator.hasNext()){
Object o=iterator.next();//统一的接口来访问具体的集合元素.
}
普通for循环与高级for循环的区别：
普通for循环能够将以部分代码重复执行很多遍，而高级for循环不行。
例如：
for(int i=0;i<i00;i++)
{
        System.out.println("hello java");
}
高级for循环与迭代器的区别：
增强for循环的内部底层是调用iteratoer来实现的，
但是增强for循环 不能在增强循环里动态的对集合的内容进行增删等操作同时也不能获取下标等。
例如：
package cn.itcast.day1;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Demo
{
        public static void main(String[] args)
        {
                List<String> li=new ArrayList<String>();
                li.add("abc");
                li.add("abb");
                li.add("aba");
                //遍历集合
                //高级for
                for(String str:li)
                {
                        System.out.println(str);
                }
                System.out.println("-----------------------------");
                //迭代器
                Iterator<String> it = li.iterator();
                while(it.hasNext())
                {
                        String str=it.next();
                        if(str=="aba")//能进行增删判断灯操作。
                        {
                                it.remove();
                        }
                        else
                        System.out.println(str);
                }
        }
}

增强for循环的内部是调用iterator实现的，但是增强for循环较之有缺点：不能在循环中动态的删除集合元素，不能获取下标
因此，对于下标明确的集合，例如ArrayList，使用普通的for循环，而对于其他的如LinkedList，则使用增强for循环

高级的for 是指的 foreach 吗.
foreach的格式 是
for (循环变量类型 循环变量名称 : 要被遍历的对象)
{
      循环体
}


高级的for()循环可以实现查找但是不能用于删除元素，
不过迭代器可以

只知道这么多了  来向大家学习  

12期偶来了{:soso_e100:}

普通for循环、高级for循环、迭代器都是循环控制语句

普通for循环、高级for循环、迭代器都是循环控制语句
一般用来打印输出元素

注意：高级for循环一定要指定数据类型
例：用普通for循环、高级for循环、迭代器
操作同一个循环。

import java.util.*;
public class CollectionDemo
{
        public static void main(String[] args)
        {
  
                    method_get();
         }
          public static void method_get()
          {
  
                    ArrayList<String> al = new ArrayList();
  
  
                    al.add("java01");
                    al.add("java02");
                    al.add("java03");
                    al.add("java04");
                     /*
  
                   //用迭代Iterator循环
                   Iterator it = al.iterator();
                  // boolean hasNext()  如果仍有元素可以迭代，则返回 true。
                    while(it.hasNext())
                    {
                            System.out.println(it.next());
                     }
                    */
  
                    /*
                     //用for循环
                       for(Iterator it = al.iterator();it.hasNext();)
                       {
                                System.out.println(it.next());
                        }
                       */
   
                         //用for循环增强
                       for(String str:al)        //注意要有数据类型
                       {
                                 System.out.println(str);
                        }
  
  
            }
}

高级for循环就是用iterator实现的。而相比于普通的for循环 由于它只需要做一次边界检查 所以理论上性能会稍优。

三种遍历方法区别：
传统for循环对于遍历数组的时候可以定义脚标。例如

1. 
   
2.                 int[] arr = {3,5,1};
   
3. 
   
4.                 for(int x=0; x<arr.length; x++)
   
5.                 {
   
6.                         System.out.println(arr[x]);
   
7.                 }

复制代码

所以遍历数组时，通常还是会使用传统for循环。
高级for循环只能对集合进行取出不能进行修改，这点能保证元素不变。且书写简单，局限性是必须要有遍历的目标。
迭代器比高级for循环多了个remove方法，便多了个删除性的取出。而ListIterator，还可以在遍历过程中对集合进行增删改查的动作。

普通for和高级for都可以遍历数组，迭代器不可以遍历数组。普通for可以自定义角标，可以对数组元素进行赋值、删除，高级for只能读取数组元素，不能赋值

高级for和迭代器都可以遍历集合，普通for不可以。同样高级for只能遍历集合元素，不能赋值、修改，迭代器Iterator只能往下遍历和删除集合元素，不能网上遍历，Iterator子类ListIterator可以向上遍历，可以调用set方法修改集合元素，可以操作集合角标

一般不需要最元素进行操作是，数组、集合都是用高级for方便，需要对元素进行操作修改，数组用普通for，集合用迭代器。

普通for和高级for都可以实现循环，高级for书写简化，但只能是“遍历体”才能使用，并且对只能“读”不能“写”，普通for可以自定义循环条件

高级for固然好用，但由于高级for语句不能确定是哪个元素，当元素的位置(   即for(int i=0;i<10;i++)中的 i  )  需要传入另一个方法时，传统的for语句就体现得更方便了！

for, foreach, 迭代器的区别和联系？

联系：三者都可以实现循环遍历。
区别：语法格式、循环条件、应用以及性能都有差异，分别介绍如下。

1.语法格式：
for:
    for（initialization; Boolean-expression; step){ statement }
foreach:
    for( type identifier : expression) { statement }
迭代器:
    Iterator<T> it = XXX.iterator();
    while(it.hasNext()){
        T t = it.next();
        //statement
    }

2.条件
for通过Boolean-expression来确定循环体是否执行
foreach不用显式确定循环条件
迭代器使用hasNext()检查序列中是否还有元素

3.应用
for用于一般的循环，最常用
foreach用于数组和集合
迭代器用于集合，只能单向移动，使用next()获得序列中的下一个元素，使用remove()将迭代器新近返回的元素删除

4.性能
for性能最优，foreach和迭代器相当
参见：http://blog.csdn.net/java2000_net/article/details/3796064


如有问题或不足希望大家指正补充。

1.增强for循环和iterator遍历的效果是一样的，也就说
增强for循环的内部也就是调用iteratoer实现的(可以查看编译后的文件)，但是增强for循环 有些缺点，例如不能在增强循环里动态的删除集合内容。不能获取下标等。
2.ArrayList由于使用数组实现，因此下标明确，最好使用普通循环。
3.而对于 LinkedList 由于获取一个元素，要从头开始向后找，因此建议使用 增强for循环，也就是iterator。
迭代器是一种设计模式，它是一个对象，它可以遍历并选择序列中的对象，而开发人员不需要了解该序列的底层结构。迭代器通常被称为“轻量级”对象，因为创建它的代价小。
Java中的Iterator功能比较简单，并且只能单向移动。

增强for循环使用迭代器实现的，普通for循环和增强for循环是两种不同的循环方式，普通for循环不能使用迭代器，增强for循环和普通for循环不能移除元素，但是迭代器可以移除元素。

普通for循环，高级for循环，迭代器的联系和区别：
先说说各自的特点：
for循环的格式：for(初始化表达式；条件表达式；步进运算)
                                                   {执行语句；}
for循环的使用范围广，初始化表达式，步进运算，执行语句，条件表达式都可以为空（条件表达式不建议为空，当为空时就是死循环），初始化部分可以定义任意数量的相同类型变量：for（int i=1, j= i+10; x<5; i++, j=i*2){........}
高级for循环格式：for（元素类型 元素名：元素所在集合（或数组） ）{
                                                                          执行语句；
                                      }
这里for的作用是:遍历数组的的每个元素，每遍历一次，用变量X来接收，是For循环的增强。是Java.5.0的新特性，适合数组和集合遍历其中元素，不适合用于遍历基本数据。正如毕老师说过，一个功能如果简化了书写格式，就会提高其局限性。
Iterator迭代器是集合特有的功能，集合通过Iterator()方法获取迭代器对象，通过hasNext()和next()方法遍历集合中的所有元素。所有迭代器只能在集合中使用。
综上所述：从功能上说，它们都是用来遍历数据的，但它们所针对的数据类型不同，所使用的范围也不一样，具体使用时看你操作数据的类型而定。

看了半天，好像没有人得了技术分吧？这帖子。。。

普通for循环:需要定义循环开始变量，循环结束变量来确定循环次数，通过循环条件变化语句来改变循环变量。循环流程是：确定循环开始变量，判断是否符合循环结束条件，若不符合，执行循环代码，然后再执行循环条件变化语句，再判断是否符合循环结束条件，若符合，结束判断，不符合则继续。
其一般格式为：
for(初始值 ;条件判断 ;变量操作 ){循环体}

高级for用来遍历Collection或者数组，但是只能获取元素，不能对其进行操作。高级for有一个局限性，必须有被遍历的目标。相对于传统for，简化了代码。
一般遍历数组，还是建议使用传统for,因为可以定义脚标。
其一般格式为：
for(数据类型 变量名：数组或者实现了Iterable接口的集合类){  循环体}

迭代器主要应用于集合中，只能单向移动，使用next()获得序列中的下一个元素，使用remove()将迭代器新近返回的元素删除。
其一般格式为：
while(iterator.hasNext()){
Object o=iterator.next();
}