java容器：Collection中的Iterator和Map中的entrySet对比学习

对于和我一样的初学者，请参考我的前篇博文：java四器之迭代器初学：
http://blog.csdn.net/managementandjava/article/details/51404884
和git@code.csdn.net:snippets/1691286.git
一起学习，希望对初学者有一定的帮助，共勉！

package com.Collection;

import java.util.*;

/*需求分析：
 *  本次练习来对比学习Collection容器和Map集合的取出元素的两种方式：
 * 
 * 1.在Collection中我们是通过迭代器来取出元素，
 *  1.1实例见类IteratorForList
 *  1.2其内部实现原理：见注释
 *  1.3仿造内部原理构建自己的迭代器；
 * 2.在Map集合中我们通过 keySet()和entrySet()方法取出元素
 *  2.1 Set<K> keySet()
 *          ---->通过keySet()方法把所有的键值放到一个Set集合中，
 *          --->>再通过Set集合的迭代器和map的get(Object k)得到所有的值；
 *          --->>实例见：KeySetForMap类
 *  2.2 Set<Map.Entry<K,V>> entrySet():  返回此映射中包含的映射关系的 Set 视图
 *          --->>通过entrySet()把键和值的映射关系放入Set集合中，
 *          --->>这种映射关系就用Map.Entry来表示；
 *          --->>根据这种关系来取出相应的键和值；
 *          --->>实例见：EntrySetForMap
 *  2.3分析Map.Entry接口内部实现形式：
 *          --->>见注释部分的示例2.3；
 * */

/*  1.2实例
 *  interface Iterable<T>{
        public Iterator<T> iterator();
    }

    interface Iterator<E>{
        public boolean hasNext();
        public E next();
    }
    interface Collection<E> extends Iterable<E>{
        public Iterator<E> iterator();
    }

    interface List<E> extends Collection<E>{
         Iterator<E> iterator();
    }

    class ArrayList<E> implements List<E>{

         public Iterator<E> iterator() {
                return new Itr();
         }
         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() {
                    return cursor != size;
                }
                public E 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;
                    return (E) elementData[lastRet = i];
                }
         }
    }

    因此当我们：
        List<String> infoList = new ArrayList<String>(list);

        //通过迭代器取出元素并代用next和hasNext方法是否实际上是调用的ArrayList实现的内部类中的方法；
        Iterator<String> it = infoList.iterator();

        while(it.hasNext()){
            String element = it.next();
            System.out.print(element+" ");
        }
    类此与这样的设计结构我们也可以定义我们自己的迭代器和数据集合结构：1.3



//示例2.3：分析Map.Entry源代码：
 public interface Map<K,V> {
     interface Entry<K,V> {
         K getKey();
         V getValue();
         //其他方法省略
     }
 }
 分析：为什么定义成内部接口；因为Entry表示的是Map键值对之间的映射关系；
 而这种关系是建立在Map集合的基础上；

 其实现必然也是外部类实现Map接口，内部类实现Map.Entr接口来操作的；
 public class HashMap implements Map{

    static class Node implements Map.Entry{

    }
 }

看HashMap中实现的源代码 必然是从内部类来实现的；
 //简化如下：
 class HashMap{

    //第一步：让一个静态内部类实现Map.Entry接口中的所有方法；
    static class Node<K,V> implements Map.Entry<K,V> {
        //定义节点Node的构造器。实现Entry接口中的方法；
    }
    //当我们想要调用entrySet()方法拿到映射关系的集合,并且想通过集合对象
    //(键值之间的关系)来取得相应的键和值时，
    //拿到映射关系的集合：通过EntryIterator的next()方法来拿到关系对象；
    //这就和ArrayList中的迭代器实现原理相似：如下
    public Set<Map.Entry<K,V>> entrySet() {
        //返回一个新的类 即： EntrySet类;
        return (es = entrySet) == null ? (entrySet = new EntrySet()) : es;
    }
    final class EntrySet extends AbstractSet<Map.Entry<K,V>> {
        //返回一个新的类 即： EntryIterator类
        public final Iterator<Map.Entry<K,V>> iterator() {
            return new EntryIterator();
        }
    }
    abstract class HashIterator {
        //定义了自己的构造器和hasNext(); Node<K,V> nextNode(); remove()方法；
        final Node<K,V> nextNode() {
            return e;
        }
     }  
     final class EntryIterator extends HashIterator implements Iterator<Map.Entry<K,V>> {
        public final Map.Entry<K,V> next() { return nextNode(); }
    }   

 }


*/
//1.1实例
class IteratorForList{
    public static void showElement(){
        String[] infoes =("hello java wo should say hello to the world").split(" ");
        List<String> list = Arrays.asList(infoes);
        List<String> infoList = new ArrayList<String>(list);

        //通过迭代器取出元素
        Iterator<String> it = infoList.iterator();
        while(it.hasNext()){
            String element = it.next();
            System.out.print(element+" ");
        }
    }

}

//1.3实例
interface MyIterable<E>{
    MyIterator<E> myIterator();
}
interface MyIterator<E>{
    public boolean hasPre();
    public E previous();
}
class MyList implements MyIterable<String>{

    String[] infoes = "hello java : wo should say hello to the world !!".split(" ");

    @Override
    public MyIterator<String> myIterator() {
        return new MyIter();
    }
    private class MyIter implements MyIterator<String>{
        int count=infoes.length;
        @Override
        public boolean hasPre() {
            if(count-->0)
                return true;
            return false;
        }
        @Override
        public String previous() {
            return infoes[count];
        }
    }
}

//2.1+2.2所需的资源对象；
class StuInfo{
    public static Map<Integer,String> showInfo(){
        Map<Integer,String> stuInfo  = new HashMap<Integer,String>();
        stuInfo.put(101, "xiaoming");
        stuInfo.put(102, "xiaoHua");
        stuInfo.put(103, "xiaoGuo");
        stuInfo.put(104, "xiaoWeng");
        stuInfo.put(105, "xiaoLv");

        return stuInfo;
    }
}
//2.1实例
class KeySetForMap{
    public static void showElement(){
        Map<Integer,String> stuInfo = StuInfo.showInfo();
        Set<Integer> keySet = stuInfo.keySet();
        for(Iterator<Integer> it = keySet.iterator();it.hasNext();){
            Integer next = it.next();
            System.out.println("key: "+next+" value: "+stuInfo.get(next));
        }

    }



}
//2.2实例
class EntrySetForMap{
    public static void showElement(){
        Map<Integer,String> stuInfo = StuInfo.showInfo();
        //第一步拿到映射关系的集合
        Set<Map.Entry<Integer, String>> entrySet = stuInfo.entrySet();
        //用set容器的迭代器方式取出各个元素；
        for(Iterator<Map.Entry<Integer, String>> it = entrySet.iterator();it.hasNext();){
            //拿到每一个映射关系对象；
            Map.Entry<Integer, String> entry = it.next();
            //根据映射关系的getKey()和getValue()方法得到相应的键值对；
            System.out.println("key: "+entry.getKey()+" value: "+entry.getValue());
        }
    }
}

//main:
public class IteratorVsEntrySet {

    public static void main(String[] args) {
        //1.1演示实例
        //IteratorForList.showElement();

        //1.3演示实例
        /*MyIterator<String> mi = new MyList().myIterator();
        while(mi.hasPre()){
            System.out.print(mi.previous()+" ");
        }*/

        //2.1演示实例
        KeySetForMap.showElement();

        //2.2演示实例
        EntrySetForMap.showElement();

    }
}