Iterator迭代器，while循环，增强for循环的用法

2.1 Iterator接口

由于集合框架中的集合容器太多，而每个集合容器中保存的数据存储的方式都不一样。于是导致我们往出取数据的时候方式也完全不相同。

Java针对这些所有集合容器取出数据的方式进行共性的抽取，于是针对所有的集合定义了一个接口，在这个接口中描述了所有集合容器的共性遍历规则。

注意：对于集合取元素，无论是什么数据结构，最终共性的取出方式：

一个一个取，取之前先判断，有，取一个，没有，结束。

这种取出的共性方式：迭代。迭代可以理解为取出或者遍历。

而这个接口它就是java.util.Iterator，它中定义了集合最基本的遍历方式：

terator接口的迭代(取出、遍历)方式：

针对一个集合，需要遍历的时候，应该首先去判断集合中有没有元素（对象），有就取出这个元素，没有就不用再进行遍历了。
方法：

​ public boolean hasNext():如果仍有元素可以迭代，则返回 true。

​ hasNext()函数表示判断容器中还有没有元素，如果有返回true，我们就可以根据这个返回的结果确定到底还要不要遍历这个集合容器。

​ public E next():返回迭代的下一个元素。

​ next()函数表示取出当前遍历到的那个元素。

其实通过以上的分析我们不难得知，要想获得迭代器对象必须得先创建一个集合的对象，然后

通过集合对象调用Collection接口中的iterator()函数就可以生成迭代器对象，如下所示：

public Iterator iterator(): 获取集合对应的迭代器，用来遍历集合中的元素的。

说明：由于集合种类有很多，各不相同，所以迭代器对象也会有很多，针对不同集合获得不同的迭代器对象，但是最后使用迭代器对象调用Iterator迭代器中的函数实现的效果是一致的，没有区别，即：

根据迭代器对象调用hasNext()函数查看集合容器中是否含有要遍历的元素，调用next()函数获取集合容器中的元素。

while循环的迭代和for循环的迭代有什么不同？

while循环的迭代，由于初始化迭代器对象在while循环上面，在整个while循环结束后，迭代器对象还可以继续使用，但是集合中已经没有数据了，如果还仍然使用迭代器对象继续获取数据，会报异常，如果还要获取，需要重新在获取一个迭代器对象。所以对于while循环当迭代器对象使用完之后，迭代器就会变成一个没有用的垃圾，占内存。

对于for循环的迭代，由于初始化迭代器对象在for循环小括号中，在整个for循环结束后，迭代器对象就不能继续使用，也不会占内存，所以建议大家以后在开发中使用迭代器遍历集合最好使用for循环。

增强for循环(也称for each循环)是JDK1.5以后出来的一个高级for循环，专门用来遍历数组和集合的。它的内部原理其实是个Iterator迭代器。

foreach循环，也称为高级for循环或者叫做增强for循环。它可以简化普通的for循环。foreach 不能完全代替普通的for循环。

普通for循环的格式：

for( 循环初始化; 循环条件 ; 修改循环条件 ){

循环体

}

foreach循环：

for( 数组或集合中元素的类型 变量名 : 数组名或集合名 ){

//变量名所指的空间中，保存的是从数组或者集合中取出的数据

}

注意：foreach循环它仅仅只能用来完成遍历，不能对操作的数组或集合中的数据进行修改操作。

package IteratorTest;

import java.util.*;

public class Iterator1 {
    public static void main(String[] args) {
        Collection collection = new ArrayList<String>();
        collection.add("aaa");
        collection.add('a');
        collection.add(1.2);
        collection.add(111);
        collection.add(true);

        for (Object o : collection) {
            System.out.print(o + " ");
        }
        System.out.println();

        Iterator iterator = collection.iterator();
        while (iterator.hasNext()) {
            System.out.print(iterator.next() + " ");
        }
        System.out.println();

        List<String> list = new ArrayList<>();
        Collections.addAll(list, "11", "22", "33");

        for (String s : list) {
            System.out.print(s + " ");
        }
        System.out.println();

        for (Iterator iterator1 = list.iterator(); iterator1.hasNext(); ) {
            System.out.print(iterator1.next() + " ");
        }
    }
}

package SetTest;


import java.util.*;


public class Set1 {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<String, String>();
        map.put("b", "4");
        map.put("a", "5");
        map.put("c", "3");
        map.put("d", "5");

        Iterator<String> iter = map.keySet().iterator();
        while (iter.hasNext()) {
            String key = iter.next();
            String value = map.get(key);
            System.out.println(key + " " + value);
        }
        System.out.println();

        Iterator<Map.Entry<String, String>> iter1 = map.entrySet().iterator();
        while (iter1.hasNext()) {
            Map.Entry<String, String> entry = iter1.next();
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key + " " + value);
        }
    }
}

package MapTest;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;
/**
 *foreach的底层就是用iterator来实现的
 * 所以他们可以互相转换的
 */

public class Map7 {
    public static void main(String[] args) {
        HashMap<Integer, String[]> map = new HashMap<>();
        map.put(1, new String[]{"222"});
        map.put(2, new String[]{"110,111,112,113"});
        map.put(3, new String[]{"333"});
        map.put(4, new String[3]);

        Set<Integer> keySet = map.keySet();
        for (Integer key : keySet) {
            String[] strings = map.get(key);
            boolean array = strings.getClass().isArray();
            System.out.println("array = " + array);
        }
        System.out.println();
        //foreach效果等同于iterator迭代器
        Iterator<Integer> iterator = keySet.iterator();
        while (iterator.hasNext()){
            Integer key = iterator.next();
            String[] strings = map.get(key);
            boolean array = strings.getClass().isArray();
            System.out.println("array = " + array);
        }
    }
}

package ArrayTest;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

public class Array13 {
    public static void main(String[] args) {

        Object[] arr = new Object[4];
        System.out.println("arr.length = " + arr.length);
        for (Object o : arr) {
            System.out.println("o = " + o);
        }
        System.out.println();

        Map<Object, Object> map = new HashMap<>();
        map.put(new Object(), new Object());
        map.put(new Object(), new Object());
        map.put(new Object(), new Object());

        for (Object key : map.keySet()) {
            Object value = map.get(key);
            System.out.println("key = " + key + " " + "value = " + value);
        }
        System.out.println();

        Iterator<Object> iterator1 = map.keySet().iterator();
        while (iterator1.hasNext()){
            Object key = iterator1.next();
            Object value = map.get(key);
            System.out.println("key = " + key + " " + "value = " + value);
        }
        System.out.println();

        for (Map.Entry<Object, Object> entry : map.entrySet()) {
            Object key = entry.getKey();
            Object value = entry.getValue();
            System.out.println("key = " + key + " " + "value = " + value);
        }
        System.out.println();

        Iterator<Map.Entry<Object, Object>> iterator = map.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry<Object, Object> entry = iterator.next();
            Object key = entry.getKey();
            Object value = entry.getValue();
            System.out.println("key = " + key + " " + "value = " + value);
        }
    }
}