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当然还是循环体.
