JDK1.5新特性之---增强for循环

1
for(变量类型 变量　：需迭代的数组或集合){}

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
public class App {

    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());
        }


    }

}

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
package cn.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;  // 
    }

    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 Demo {

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

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



    }

}

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
 private class Itr implements Iterator<E> {
        int cursor;       // index of next element to return
        int lastRet = -1; // index of last element returned; -1 if no such
        int expectedModCount = modCount;

        public boolean hasNext() { //hasNext方法
            return cursor != size;
        }

        @SuppressWarnings("unchecked")
        public E next() { // next方法
            checkForComodification();
            int i = cursor;
            if (i >= size)
                throw new NoSuchElementException();
            Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            cursor = i + 1;  //游标加1操作
            return (E) elementData[lastRet = i];
        }

        public void remove() {//remove方法
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();

            try {
                ArrayList.this.remove(lastRet);
                cursor = lastRet;
                lastRet = -1;
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }