一般写法
1： 遍历数组的传统方式

/* 建立一个数组 */
int [] integers={1,2,3,4};
/* 开始遍历 */
for (int j=0;j<integers.length;j++){
	int i = integers[j];
     System.out.println(i);
}

2：遍历Collection对象的传统方式

/* 建立一个Collection */
 String[] strings = {"A", "B", "C", "D"};
 Collection stringList = java.util.Arrays.asList(strings);
 /* 开始遍历 */
 for (Iterator itr = stringList.iterator(); itr.hasNext();) {
     Object str = itr.next();
     System.out.println(str);
 }

第二种写法
for (循环变量类型 循环变量名称 : 要被遍历的对象) 循环体

3：遍历数组的简单方式

/* 建立一个数组 */
 int[] integers = {1, 2, 3, 4};

 /* 开始遍历 */
 for (int i : integers) {
     System.out.println(i); /* 依次输出“1”、“2”、“3”、“4” */
 }

遍历数组的简单方式的等价代码

/* 建立一个数组 */
 int[] integers = {1, 2, 3, 4};

 /* 开始遍历 */
 for (int 变量名甲 = 0; 变量名甲 < integers.length; 变量名甲++) {
     System.out.println(integers[变量名甲]); /* 依次输出“1”、“2”、“3”、“4” */
 }

4：遍历Collection的简单方式

/* 建立一个Collection */
 String[] strings = {"A", "B", "C", "D"};
 Collection list = java.util.Arrays.asList(strings);

 /* 开始遍历 */
 for (Object str : list) {
     System.out.println(str); /* 依次输出“A”、“B”、“C”、“D” */
 }

遍历数组的简单方式的等价代码

/* 建立一个Collection */
 String[] strings = {"A", "B", "C", "D"};
 Collection stringList = java.util.Arrays.asList(strings);

 /* 开始遍历 */
 for (Iterator 变量名乙 = list.iterator(); 变量名乙.hasNext();) {
     Object str = 变量名乙.next();
     System.out.println(str); /* 依次输出“A”、“B”、“C”、“D” */
 }

防止在循环体里修改循环变量
5：禁止重新赋值

int[] integers = {1, 2, 3, 4};
 for (final int i : integers) {
     i = i / 2; /* 编译时出错 */
 }

这只是禁止了对循环变量进行重新赋值。给循环变量的属性赋值，或者调用能让循环变量的内容变化的方法，是不被禁止的。
在这里插入图片描述

6：允许修改状态

Random[] randoms = new Random[]{new Random(1),new Random(2), new Random(3)};
 for (final Random r : randoms) {
     r.setSeed(4); /* 将所有Random对象设成使用相同的种子 */
     System.out.println(r.nextLong()); /* 种子相同，第一个结果也相同 */
 }

类型相容问题
7：使用和要被遍历的数组中的元素相同类型的循环变量

int[] integers = {1, 2, 3, 4};
 for (int i : integers) {
     System.out.println(i); /* 依次输出“1”、“2”、“3”、“4” */
 }

8：使用和要被遍历的Collection中的元素相同类型的循环变量

Collection< String> strings = new ArrayList< String>();
		strings.add("A");
		strings.add("B");
		strings.add("C");
		strings.add("D");
		for (String str : strings) {
		System.out.println(str); /* 依次输出“A”、“B”、“C”、“D” */
		}

循环变量的类型可以是要被遍历的对象中的元素的上级类型。 例如，用int型的循环变量来遍历一个byte[]型的数组，用Object型的循环变量来遍历一个Collection< String>（全部元素都是String的Collection）等。

9：使用要被遍历的对象中的元素的上级类型的循环变量

String[] strings = {"A", "B", "C", "D"};
Collection< String> list = java.util.Arrays.asList(strings);
for (Object str : list) {
System.out.println(str);/* 依次输出“A”、“B”、“C”、“D” */
}

10：使用能和要被遍历的对象中的元素的类型自动转换的类型的循环变量

int[] integers = {1, 2, 3, 4};
for (Integer i : integers) {
System.out.println(i); /* 依次输出“1”、“2”、“3”、“4” */
}

这里说的“元素的类型”，是由要被遍历的对象的决定的――如果它是一个Object[]型的数组，那么元素的类型就是Object，即使里面装的都是String对象也是如此。