文章标题

jdk1.5出现的新特性—->增强for循环
增强for循环的作用： 简化迭代器的书写格式。(注意：增强for循环的底层还是使用了迭代器遍历。)
增强for循环的适用范围： 如果是实现了Iterable接口的对象或者是数组对象都可以使用增强for循环。

增强for循环的格式： 
  for(数据类型  变量名  :遍历的目标){   //数据类型  变量名:声明一个变量用来接收遍历目标遍历后的元素
 
  }
增强for循环要注意的事项：
1. 增强for循环底层也是使用了迭代器获取的，只不过获取迭代器由jvm完成，不需要我们获取迭代器而已，所以在使用增强for循环变量元素的过程中不准使用集合
        对象对集合的元素个数进行修改。
2. 迭代器遍历元素与增强for循环变量元素的区别：使用迭代器遍历集合的元素时可以删除集合的元素，而增强for循环变量集合的元素时，不能调用迭代器的remove方法删                 除 元素。

3. 普通for循环与增强for循环的区别：普通for循环可以没有遍历的目标，而增强for循环一定要有遍历的目标。

[java] view plain copy

print ?

1. public class Demo2 {  
2.       
3.     public static void main(String[] args) {  
4.         HashSet<String> set = new HashSet<String>();  
5.         //添加元素  
6.         set.add(”狗娃”);  
7.         set.add(”狗剩”);  
8.         set.add(”铁蛋”);  
9.           
10.         /* 
11.         //使用迭代器遍历Set的集合. 
12.         Iterator<String> it  = set.iterator(); 
13.         while(it.hasNext()){ 
14.             String temp = it.next(); 
15.             System.out.println(“元素：”+ temp); 
16.             it.remove(); 
17.         } 
18.          
19.          
20.         //使用增强for循环解决 
21.         for(String item : set){ 
22.             System.out.println(“元素：”+ item); 
23.              
24.         } 
25.          
26.          
27.          
28.          
29.         int[] arr = {12,5,6,1}; 
30.          
31.         普通for循环的遍历方式 
32.         for(int i =  0 ; i<arr.length ; i++){ 
33.             System.out.println(“元素：”+ arr[i]); 
34.         } 
35.          
36.         //使用增强for循环实现 
37.         for(int item :arr){ 
38.             System.out.println(“元素：”+ item); 
39.         } 
40.          
41.          
42.          
43.         //需求： 在控制台打印5句hello world. 
44.         for(int i = 0 ; i < 5; i++){ 
45.             System.out.println(“hello world”); 
46.         } 
47.         */  
48.           
49.         //注意： Map集合没有实现Iterable接口，所以map集合不能直接使用增强for循环，如果需要使用增强for循环需要借助于Collection  
50.         // 的集合。  
51.         HashMap<String, String> map = new HashMap<String, String>();  
52.         map.put(”001”,“张三”);  
53.         map.put(”002”,“李四”);  
54.         map.put(”003”,“王五”);  
55.         map.put(”004”,“赵六”);  
56.         Set<Map.Entry<String, String>> entrys = map.entrySet();  
57.         for(Map.Entry<String, String> entry  :entrys){  
58.             System.out.println(”键：”+ entry.getKey()+“ 值：”+ entry.getValue());  
59.         }  
60.           
61.           
62.     }  
63.   
64. }  

public class Demo2 {

    public static void main(String[] args) {
        HashSet<String> set = new HashSet<String>();
        //添加元素
        set.add("狗娃");
        set.add("狗剩");
        set.add("铁蛋");

        /*
        //使用迭代器遍历Set的集合.
        Iterator<String> it  = set.iterator();
        while(it.hasNext()){
            String temp = it.next();
            System.out.println("元素："+ temp);
            it.remove();
        }


        //使用增强for循环解决
        for(String item : set){
            System.out.println("元素："+ item);

        }




        int[] arr = {12,5,6,1};

        普通for循环的遍历方式
        for(int i =  0 ; i<arr.length ; i++){
            System.out.println("元素："+ arr[i]);
        }

        //使用增强for循环实现
        for(int item :arr){
            System.out.println("元素："+ item);
        }



        //需求： 在控制台打印5句hello world.
        for(int i = 0 ; i < 5; i++){
            System.out.println("hello world");
        }
        */

        //注意： Map集合没有实现Iterable接口，所以map集合不能直接使用增强for循环，如果需要使用增强for循环需要借助于Collection
        // 的集合。
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("001","张三");
        map.put("002","李四");
        map.put("003","王五");
        map.put("004","赵六");
        Set<Map.Entry<String, String>> entrys = map.entrySet();
        for(Map.Entry<String, String> entry  :entrys){
            System.out.println("键："+ entry.getKey()+" 值："+ entry.getValue());
        }


    }

}

自定义的类也可使用增强for循环：

[java] view plain copy

print ?

1. package cn.itcast.jdk15;  
2.   
3. import java.util.Iterator;  
4.   
5. //自定一个类使用增强for循环  
6. class MyList implements Iterable<String>{  
7.       
8.     Object[] arr = new Object[10];  
9.       
10.     int index = 0 ; //当前的指针  
11.       
12.     public void add(Object o){  
13.         arr[index++] = o;  // 1  
14.     }  
15.       
16.     public int size(){  
17.         return index;  
18.     }  
19.   
20.     @Override  
21.     public Iterator<String> iterator() {  
22.           
23.           
24.         return new Iterator<String>() {  
25.   
26.             int cursor  = 0;  
27.   
28.             @Override  
29.             public boolean hasNext() {  
30.                 return cursor<index;  
31.             }  
32.   
33.             @Override  
34.             public String next() {  
35.                 return (String) arr[cursor++];  
36.             }  
37.   
38.             @Override  
39.             public void remove() {  
40.                   
41.             }  
42.         };  
43.     }  
44. }  
45.   
46. public class Demo3 {  
47.       
48.     public static void main(String[] args) {  
49.         MyList list = new MyList();  
50.         list.add(”张三”);  
51.         list.add(”李四”);  
52.         list.add(”王五”);  
53.           
54.         for(String item :list){  
55.             System.out.println(item);  
56.         }  
57.           
58.           
59.           
60.     }  
61.       
62. }  

package cn.itcast.jdk15;

import java.util.Iterator;

//自定一个类使用增强for循环
class MyList implements Iterable<String>{

    Object[] arr = new Object[10];

    int index = 0 ; //当前的指针

    public void add(Object o){
        arr[index++] = o;  // 1
    }

    public int size(){
        return index;
    }

    @Override
    public Iterator<String> iterator() {


        return new Iterator<String>() {

            int cursor  = 0;

            @Override
            public boolean hasNext() {
                return cursor<index;
            }

            @Override
            public String next() {
                return (String) arr[cursor++];
            }

            @Override
            public void remove() {

            }
        };
    }
}

public class Demo3 {

    public static void main(String[] args) {
        MyList list = new MyList();
        list.add("张三");
        list.add("李四");
        list.add("王五");

        for(String item :list){
            System.out.println(item);
        }



    }

}