foreach语句使用总结

java foreach 使用


foreach语句是java5的新特征之一，在遍历数组、集合方面，foreach为开发人员提供了极大的方便。

foreach语句是for语句的特殊简化版本，但是foreach语句并不能完全取代for语句，然而，任何的foreach语句都可以改写为for语句版本。

foreach并不是一个关键字，习惯上将这种特殊的for语句格式称之为“foreach”语句。从英文字面意思理解foreach也就是“for 每一个”的意思。实际上也就是这个意思。

foreach的语句格式：
for(元素类型t 元素变量x : 遍历对象obj){
引用了x的java语句;
}

下面通过两个例子简单例子看看foreach是如何简化编程的。代码如下：

一、foreach简化数组和集合的遍历

import java.util.Arrays;
import java.util.List;
import java.util.ArrayList;


/**
* Created by IntelliJ IDEA.
* User: leizhimin
* Date: 2007-12-3
* Time: 16:58:24
* Java5新特征之foreach语句使用总结
*/
public class TestArray {
public static void main(String args[]) {
TestArray test = new TestArray();
test.test1();
test.listToArray();
test.testArray3();


}


/**
* foreach语句输出一维数组
*/
public void test1() {
//定义并初始化一个数组
int arr[] = {2, 3, 1};
System.out.println("----1----排序前的一维数组");
for (int x : arr) {
System.out.println(x); //逐个输出数组元素的值
}


//对数组排序
Arrays.sort(arr);


//利用java新特性for each循环输出数组
System.out.println("----1----排序后的一维数组");
for (int x : arr) {
System.out.println(x); //逐个输出数组元素的值
}
}


/**
* 集合转换为一维数组
*/
public void listToArray() {
//创建List并添加元素
List<String> list = new ArrayList<String>();
list.add("1");
list.add("3");
list.add("4");


//利用froeach语句输出集合元素
System.out.println("----2----froeach语句输出集合元素");
for (String x : list) {
System.out.println(x);
}


//将ArrayList转换为数组
Object s[] = list.toArray();


//利用froeach语句输出集合元素
System.out.println("----2----froeach语句输出集合转换而来的数组元素");
for (Object x : s) {
System.out.println(x.toString()); //逐个输出数组元素的值
}
}


/**
* foreach输出二维数组测试
*/
public void testArray2() {
int arr2[][] = {{4, 3}, {1, 2}};
System.out.println("----3----foreach输出二维数组测试");
for (int x[] : arr2) {
for (int e : x) {
System.out.println(e); //逐个输出数组元素的值
}
}
}


/**
* foreach输出三维数组
*/
public void testArray3() {
int arr[][][] = {
{{1, 2}, {3, 4}},
{{5, 6}, {7, 8}}
};


System.out.println("----4----foreach输出三维数组测试");
for (int[][] a2 : arr) {
for (int[] a1 : a2) {
for (int x : a1) {
System.out.println(x);
}
}
}
}
}
运行结果：
----1----排序前的一维数组
2
3
1
----1----排序后的一维数组
1
2
3
----2----froeach语句输出集合元素
1
3
4
----2----froeach语句输出集合转换而来的数组元素
1
3
4
----4----foreach输出三维数组测试
1
2
3
4
5
6
7
8


Process finished with exit code 0
二、foreach语句的局限性

通过上面的例子可以发现，如果要引用数组或者集合的索引，则foreach语句无法做到，foreach仅仅老老实实地遍历数组或者集合一遍。下面看一个例子就明白了：

/**
* Created by IntelliJ IDEA.
* User: leizhimin
* Date: 2007-12-3
* Time: 17:07:30
* foreach语句的局限性
*/
public class TestArray2 {


public static void main(String args[]) {
//定义一个一维数组
int arr[] = new int[4];
System.out.println("----未赋值前输出刚刚定义的数组----");
for (int x : arr) {
System.out.println(x);
}


//通过索引给数组元素赋值
System.out.println("----通过循环变量给数组元素赋值----");
for (int i = 3; i > 0; i--) {
arr[i] = i;
}
//循环输出创建的数组
System.out.println("----赋值后，foreach输出创建好的数组----");
for (int x : arr) {
System.out.println(x);
}
}
}
运行结果：

----未赋值前输出刚刚定义的数组----
0
0
0
0
----通过循环变量给数组元素赋值----
----赋值后，foreach输出创建好的数组----
0
1
2
3


Process finished with exit code 0
三、总结

foreach语句是for语句特殊情况下的增强版本，简化了编程，提高了代码的可读性和安全性（不用怕数组越界）。相对老的for语句来说是个很 好的补充。提倡能用foreach的地方就不要再用for了。在用到对集合或者数组索引的情况下，foreach显得力不从心，这个时候是用for语句的 时候了。foreach一般结合泛型使用.




java中foreach 博客分类： java
Java.Java代码
1.public class TestForEach {
2.
3. /**
4. * @param args
5. */
6. public static void main(String[] args) {
7. Aeach[] a = new Aeach[2];
8.
9. //第一种赋值方式
10.
11. // for (int i = 0; i < a.length; i++) {
12. // a[i] = new Aeach();
13. // }
14.
15. //第二种赋值方式
16.
17. for (Aeach aeach : a) {
18. aeach = new Aeach();
19. }
20.
21. for (Aeach aeach : a) {
22.
23. //测试是否foreach会影响数组元素
24. aeach.setName("1111111111111");
25. System.out.println(aeach);
26. }
27. System.out.println(Arrays.toString(a));
28. }
29.
30.}
31.
32.class Aeach {
33. String name = "AAAAA初始化";
34.
35. public void setName(String name) {
36. this.name = name;
37. }
38.
39. public String toString() {
40. return super.toString() + name;
41. }
42.}
public class TestForEach {


/**
* @param args
*/
public static void main(String[] args) {
Aeach[] a = new Aeach[2];


//第一种赋值方式


// for (int i = 0; i < a.length; i++) {
// a[i] = new Aeach();
// }


//第二种赋值方式


for (Aeach aeach : a) {
aeach = new Aeach();
}


for (Aeach aeach : a) {


//测试是否foreach会影响数组元素
aeach.setName("1111111111111");
System.out.println(aeach);
}
System.out.println(Arrays.toString(a));
}


}


class Aeach {
String name = "AAAAA初始化";


public void setName(String name) {
this.name = name;
}


public String toString() {
return super.toString() + name;
}
}






对上面的数组采用两种赋值方式，一个是foreach，一个是直接引用。看输入能看到采用foreach赋值打印的结果都为null，直接引用赋值能达到预期结果。


主要是因为foreach赋值的时候


for (Aeach aeach : a) {
aeach = new Aeach();
}


相当于


for(){


Aeach aeach=a[i];


aeach=new Aeach();


}


这就相当于中间产生了一个副本，采用new操作符就等于没有操作数组的元素。


我之前看到这个例子，还以为foreach操作不影响数组原来的元素呢。


后面的代码，用直接引用的循环赋值方式，然后再用aeach.setName("1111111111111");
再打印是发生了变化的。


不是自己亲自试下还真忽略了，以后得小心对待这些问题，细细想来确实就是这么回事。new这个操作符新建个对象，明显不会影响数组元素，而采用引用的方式进行操作明显会改变了。。。


1.java的foreach可以遍历数组和所有的Collection对象（Collection接口中包括iterator()，因此所有实现Collection接口的类都可以进行foreach遍历）。
2.因为JavaSE5引入了新的被称为Iterable接口，该接口包含一个能够产生Iterator的iterator()方法，并且Iterable接口被foreach用来在序列中移动。
3.因此，只要你创建的类实现了Iterable接口，就可以使用foreach进行遍历。


4.





返回一个实现了Iterable<String>的匿名内部类实例




JDK 5.0中增加了一些新的特性,但是以前只是肤浅的了解了一下,只知道怎么回事,但是根本没有用心去学习,最近觉得自己学习太浮躁了.先学着做一些笔记吧.慢慢养成习惯吧.


JDK5.0中对for语句增加了一种形式,和其他语言中的foreach比较像,所以题目取名叫JAVA中的foreach.该形式的具体语法如下:for(声明:表达式).解释一下,也就是说冒号前面是声明一个临时变量,在下面的语句中进行引用.冒号后面是表达式,应该为集合或者数组


这样看起来可能不太明白.用实例看一下:


for (Object listElement : list) {
System.out.println(listElement.toString());
// Do something else with this list element
}


这样是不是简介了许多?list为一个list对象.JDK5以前的实现方式一般是加一个临时变量i,或者是用iterator.代码如下:


for (Iterator i = list.iterator(); i.hasNext(); ) {
Object listElement = i.next();
out.println(listElement.toString());
// Do something else with this list element
}


或者


for (int i=0;i<list.size();i++) {
Object listElement = list.get(i);
out.println(listElement.toString());
// Do something else with this list element
}
相比之下,这个for的新的形式确实是使代码简洁不少.那么这种形式的原理是什么呢?它做法很聪明,只是在编译的时候转换成如下形式:


for (Iterator<E> #i = (expression).iterator(); #i.hasNext(); ) {
declaration = #i.next();
statement
}


这样估计减少了修改javac的工作量.这样做还有一个优点:如果你想用自己定义的集合来使用这种形式,很简单,只需要实现java.lang.iterable接口就可以了.


任何事物都有两面,这样做的缺点是什么呢?


这种形式的一个最大的缺点就是不能访问元素在这个集合中的定位,举个例子来说:


for (int i=0; i<args.length; i++) {
wordList.add("word " + (i+1) + ": '" + args[i] + "'");
}

for (String word : wordList) {
out.println(word);
}


这两个例子说明了问题.没法访问定位,也就没办法修改,删除这个集合中的内容.前面已经说了,这种形式是转换为Iterator形式使用的.所以Iterator能做到的,他就能做到.这种写法这么简洁,如果你只是要遍历这个集合,数组,这种写法非常适合.


这里还有需要注意的一个问题,数组集合中如果是对象的话,在声明中要定义成Object类型,不要定义成集合中数据的类型,比如下面的代码:


List list=new ArrayList();
list.add("test1");
list.add("test2");
list.add("test3");
list.add("test4");
for(String test:list){
System.out.println(test);
}


这种写法会报错,因为Iterator本来就是返回的Object对象,不能从Object转为String.


可以通过JDK5中的范型来解决,可以写成下面的形式:


List<String> list=new ArrayList<String>();
list.add("test1");
list.add("test2");
list.add("test3");
list.add("test4");
for(String test:list){
System.out.println(test);
}


Java中foreach用法,增强型的for循环的样例和解释 博客分类： java
JavaJ#.JDK1.5加入的增强for和循环.


语法是:


Java代码
1.for(ElementType element:arrayName){};
2.
3.for(ElementType element:arrayName){};
for(ElementType element:arrayName){};


for(ElementType element:arrayName){};


举个例子:(1)




Java代码
1.int[] numArray = { 1, 2, 3, 4, 5, 6 };
2.for (int i : numArray) {
3. System.out.print(i);
4.}
int[] numArray = { 1, 2, 3, 4, 5, 6 };
for (int i : numArray) {
System.out.print(i);
}




Java代码
1.int[] numArray = { 1, 2, 3, 4, 5, 6 };
2.for (int i : numArray) {
3. System.out.print(i);
4.}
int[] numArray = { 1, 2, 3, 4, 5, 6 };
for (int i : numArray) {
System.out.print(i);
}


//结果会是123456




等价于(2)


Java代码
1.int[] numArray = { 1, 2, 3, 4, 5, 6 };
2.for (int i; i < numArray.length; i++) {
3. System.out.print(numArray[i]);
4.}
int[] numArray = { 1, 2, 3, 4, 5, 6 };
for (int i; i < numArray.length; i++) {
System.out.print(numArray[i]);
}




Java代码
1.int[] numArray = { 1, 2, 3, 4, 5, 6 };
2.for (int i; i < numArray.length; i++) {
3. System.out.print(numArray[i]);
4.}
int[] numArray = { 1, 2, 3, 4, 5, 6 };
for (int i; i < numArray.length; i++) {
System.out.print(numArray[i]);
}


或者更贴切是这样的:(3)


Java代码
1.int[] numArray = { 1, 2, 3, 4, 5, 6 };
2.for (int i; i < numArray.length; i++) {
3. int j = numArray[i];// 这个j,就等价与(1)中的i
4. System.out.println(j);
5.}
int[] numArray = { 1, 2, 3, 4, 5, 6 };
for (int i; i < numArray.length; i++) {
int j = numArray[i];// 这个j,就等价与(1)中的i
System.out.println(j);
}




Java代码
1.int[] numArray = { 1, 2, 3, 4, 5, 6 };
2.for (int i; i < numArray.length; i++) {
3. int j = numArray[i];// 这个j,就等价与(1)中的i
4. System.out.println(j);
5.}
int[] numArray = { 1, 2, 3, 4, 5, 6 };
for (int i; i < numArray.length; i++) {
int j = numArray[i];// 这个j,就等价与(1)中的i
System.out.println(j);
}这个结合集合的概念和同样是JDK1.5加入的泛性,可以做到简化代码的作用.比如




Java代码
1.List<Integer> intList = new ArrayList<Integer>();
2.for (Integer i : intList) {
3. System.out.print(i);// 可以打印出intList中的所有元素
4.}
5.
6. List<Integer> intList = new ArrayList<Integer>();
7. for (Integer i : intList) {
8. System.out.print(i);// 可以打印出intList中的所有元素
9. }
List<Integer> intList = new ArrayList<Integer>();
for (Integer i : intList) {
System.out.print(i);// 可以打印出intList中的所有元素
}


List<Integer> intList = new ArrayList<Integer>();
for (Integer i : intList) {
System.out.print(i);// 可以打印出intList中的所有元素
}




增强for(part1:part2){part3};


part2中是一个数组对象,或者是带有泛性的集合.
part1定义了一个局部变量,这个局部变量的类型与part2中的对象元素的类型是一致的.
part3当然还是循环体.