增强for循环

http://m.blog.csdn.net/article/details?id=53743016

//String 数据的类型

//name 每次循环后将数据放入名为name的变量中

//names 被循环的数组或集合

foreach(String name : names){

syso(name);

}

for循环中的循环条件中的变量只求一次值！具体看最后的图片

?foreach语句是java5新增，在遍历数组、集合的时候，foreach拥有不错的性能。

?foreach是for语句的简化，但是foreach并不能替代for循环。可以这么说，任何foreach都能改写为for循环，但是反之则行不通。

?foreach不是java中的关键字。foreach的循环对象一般是一个集合，List、ArrayList、LinkedList、Vector、数组等。

for(元素类型T 每次循环元素的名称O : 循环对象){

　　　　　　　　//对O进行操作

　　　　}

一、常见使用方式。

1. foreach遍历数组。

?


1

2

3

4

5

6

7

8

9

10

11

12

/**

 * 描述：

 * Created by ascend on 2016/7/8.

 */

public class Client {

  public static void main(String[] args) {

    String[] names = {"beibei", "jingjing"};

    for (String name : names) {

      System.out.println(name);

    }

  }

}

2.foreach遍历List。

?


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

/**

 * 描述：

 * Created by ascend on 2016/7/8.

 */

public class Client {

  public static void main(String[] args) {

    List<String> list = new ArrayList();

    list.add("a");

    list.add("b");

    list.add("c");

    for(String str : list){

      System.out.println(str);

    }

  }

}

二、局限性。

foreach虽然能遍历数组或者集合，但是只能用来遍历，无法在遍历的过程中对数组或者集合进行修改，而for循环可以在遍历的过程中对源数组或者集合进行修改。

1.数组

?


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

/**

 * 描述：

 * Created by ascend on 2016/7/8.

 */

public class Client {

  public static void main(String[] args) {

    String[] names = {"beibei", "jingjing"};

    for (String name : names) {

      name = "huanhuan";

    }

    //foreach

    System.out.println("foreach:"+Arrays.toString(names));

    //for

    for (int i = 0; i < names.length; i++) {

      names[i] = "huanhuan";

    }

    System.out.println("for:"+Arrays.toString(names));

  }

}

输出：

foreach:[beibei, jingjing]

for:[huanhuan, huanhuan]

2.集合

?


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

/**

 * 描述：

 * Created by ascend on 2016/7/8.

 */

public class Client {

  public static void main(String[] args) {

    List<String> names = new ArrayList<String>();

    names.add("beibei");

    names.add("jingjing");

    //foreach

    for(String name:names){

      name = "huanhuan";

    }

    System.out.println(Arrays.toString(names.toArray()));

    //for

    for (int i = 0; i < names.size(); i++) {

      names.set(i,"huanhuan");

    }

    System.out.println(Arrays.toString(names.toArray()));

  }

}

输出：

[beibei, jingjing]

[huanhuan, huanhuan]

特别注意的地方！！

===================================================

===================================================

For-Each循环

For-Each循环也叫增强型的for循环，或者叫foreach循环。

For-Each循环是JDK5.0的新特性（其他新特性比如泛型、自动装箱等）。

For-Each循环的加入简化了集合的遍历。

其语法如下：

?


1

2

3

4

5

6

7

for(type
element: array)

{

   System.out.println(element);

}

例子

代码中首先对比了两种for循环；之后实现了用增强for循环遍历二维数组；最后采用三种方式遍历了一个List集合。

?


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

import

java.util.ArrayList;

import

java.util.Iterator;

import

java.util.List;

public

class
ForeachTest

{

  public

static
void
main(String[] args)

  {

    int[]
arr = {1,
2,
3,
4,
5};

    

    System.out.println("----------旧方式遍历------------");

    //旧式方式   

    for(int

i=0;
i<arr.length; i++)

    {

      System.out.println(arr[i]);

    }

    

    System.out.println("---------新方式遍历-------------");

    

    //新式写法,增强的for循环

    for(int

element:arr)

    {

      System.out.println(element);

    }

    

    System.out.println("---------遍历二维数组-------------");

    

    //遍历二维数组

    

    int[][]
arr2 = {{1,
2,
3},
{4,
5,
6},
{7,
8,
9}}
;

    

    for(int[]
row : arr2)

    {

      for(int

element : row)

      {

        System.out.println(element);

      }

    }

    

    //以三种方式遍历集合List

    

    List<String>
list = new

ArrayList<String>();

    

    list.add("a");

    list.add("b");

    list.add("c");

    

    System.out.println("----------方式1-----------");

    //第一种方式，普通for循环

    for(int

i = 0;
i < list.size(); i++)

    {

      System.out.println(list.get(i));

      

    }

    

    System.out.println("----------方式2-----------");

    //第二种方式，使用迭代器

    for(Iterator<String>
iter = list.iterator(); iter.hasNext();)

    {

      System.out.println(iter.next());

    }

    System.out.println("----------方式3-----------");

    //第三种方式，使用增强型的for循环

    for(String
str: list)

    {

      System.out.println(str);

      

    }

  }

}

For-Each循环的缺点：丢掉了索引信息。

当遍历集合或数组时，如果需要访问集合或数组的下标，那么最好使用旧式的方式来实现循环或遍历，而不要使用增强的for循环，因为它丢失了下标信息。

以上就是小编为大家带来的浅谈java 增强型的for循环 for each的全部内容了

=========================================================================

========================================================================

foreach遍历原理解析

5

为什么有些类可以可以用foreach遍历,有些类却不可以了.经反编译过后得出:

-------------------------------------------------------------------------------下面我们来看看自己如何实现一个类遍历-------------------------------------------------------------------------------

[csharp] view
plain copy

  1. using
    using
    using
    using
    using

    namespace

    class

    staticvoidstring

    new
    ;

  2. ;
  3. ;
  4. foreachstringin
  5. publicclass

    privatestringnewstring

    publicint

    get

    returnthis

    publicstringthisint

    get

    return

    set

    if

    else

    publicstring

    get
    set

    publicint

    get
    set

    publicstring

    get
    set

  6. #region IEnumerable 成员
  7. public

    returnnew

  8. #endregion
  9. publicclass

    publicstring

  10. privatestring
  11. privateint
  12. #region IEnumerator 成员
  13. publicobject

    get

    if

    returnnull

    return

  14. publicbool

    if

    returnfalse

    else

    returntrue

    publicvoid

  15. #endregion

    }

时间： 2024-10-08 20:50:22

增强for循环的相关文章

Java Iterator和增强for循环 for each详解

Iterator是Java中的一个迭代器接口(Interface),用来提供标准的Java迭代器 Iterator支持泛型因为集合(Collection)类可以装入的类型是不确定的,从集合中取出的都是Object类型,加入泛型,就是告诉编译器确定要装入的对象类型,取值时就无需强制转换了. for each 是 Java 5 中新增的一个循环结构,本质上是一个Iterator,特点是可以用来遍历集合元素而不用考虑集合下标. 综合实例: package net.csdn.shf4715; impor

Java学习——增强for循环、switch

增强for循环 Java5引入了一种主要用于数组的增强型for循环. 例子 public class ForTest { public static void main(String args[]){ int [] numbers = {1, 3, 5, 7, 2, 4, 6, 8}; for (int x: numbers){ System.out.print(x); System.out.print(","); } System.out.println(); String [] n

Java5新特性之静态导入、可变参数、增强for循环、自动拆装箱

JDK1.5已经发布很长时间,之所以还拿出来是因为它增加了很多个重要的特性,使用这些特性有助于我们简化开发,编写的代码更加简洁清晰安全,主要有以下几个特性: ?  静态导入 ?  可变参数 ?  增强for循环 ?  自动拆装箱 ? 泛型 ? 枚举 由于泛型.枚举内容比较多,也最重要,之后单拿出来讲.这里先介绍前面四个简单而又实用的小特性. 1. 静态导入 所谓"静态导入"只不过是在普通的import语句中加入关键字static,例如: ?  非静态导入:import java.lan

foreach（增强for循环）和for的区别

首先说一下foreach有的也叫增强for循环,foreach其实是for循环的一个特殊简化版. 再说一下foreach的书写格式: for(元素类型  元素名称 : 遍历数组(集合)(或者能进行迭代的)){ 语句 } foreach虽然是for循环的简化版本,但是并不是说foreach就比for更好用,foreach适用于循环次数未知,或者计算循环次数比较麻烦情况下使用效率更高,但是更为复杂的一些循环还是需要用到for循环效率更高. 我们看看下面的例子: 1 public static voi

(14)jdk1.5开始的一些新特性：静态导入,增强for循环，可变参数，自动装箱/拆箱，枚举类型

Jdk1.5新特性之静态导入 jdk1.5新特性值静态导入 静态导入的作用:简化缩写 静态导入的作用:可以作用一个类的所有静态成员. 静态导入的格式:import static 包名.类名.静态的成员 import static java.util.Collections.sort; //静态导入指定的某个静态成员方法 import static java.util.Collections.*;  导入所有的静态成员 除了可以导入静态的成员方法,也可以静态的导入成员变量,比如System.out

JDK5.0新特性-增强for循环

============== 增强for循环 它的底层实现就是使用Iterator. 什么样的容器可以使用增强for?-----------Iterable 增强for的缺点:只能进行遍历,不能进行在遍历过程中的操作. 增强for的格式 for(类型 引用:容器){ } -------------------------------------------- 关于对集合的遍历. List 1.Iterator 2.增强for 3.普通for 4.ListIterator Set 1.增强for

jdk1.5出现的新特性----&gt;增强for循环

package cn.itcast.jdk15; import java.util.HashMap;import java.util.HashSet;import java.util.Iterator;import java.util.Map;import java.util.Set; /*jdk1.5出现的新特性---->增强for循环 增强for循环的作用: 简化迭代器的书写格式.(注意:增强for循环的底层还是使用了迭代器遍历.) 增强for循环的适用范围: 如果是实现了Iterable接

Java重要技术(3)语法之增强for循环

1.1. 增强for循环 增强for循环可以在某些时候简化对数组和集合的遍历.增强for循环需要集合实现了Iterable接口. public static void main(String[] args) { //遍历数组 for(String s : args){ System.out.println(s); } ArrayList<Integer> arrayList = new ArrayList<Integer>(); arrayList.add(1); arrayLis

增强for循环学习笔记

package com.lc.day01.ForEnhance; import java.util.ArrayList; import java.util.Iterator; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.util.Map.Entry; import java.util.Set; import org.junit.Test; public class