Java之集合的遍历与迭代器

集合的遍历

依次获取集合中的每一个元素

将集合转换成数组，遍历数组

//取出所有的学号, 迭代之后显示学号为1004-1009
        Object[]  c=map.keySet().toArray();//取出学号转换为数组
        System.out.println(c);
        for (int i = 0; i < c.length; i++) {

            int n=(int)c[i];//数组向下转型
            if(n>=1004&&n<=1009){
                System.out.println(n);
            }
        }

for循环与迭代器

package collectionTest;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class test {
    public static void main(String[] args) {
        List list=new ArrayList();
        list.add("aaa");
        list.add("ccc");
        list.add("vvv");
        list.add("bbb");
        list.add("nnn");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        //foreach循环遍历，没有下标，需要的话可以自己定义
        for(Object s:list){
            System.out.println(s);
        }
        Iterator iter=list.iterator();
        while(iter.hasNext()){//判断有没有下一个
            System.out.println(iter.next());
        }
        Map map=new HashMap();
        map.put("aa", 1);
        map.put("bb", 2);
        map.put("cc", 3);
        map.put("dd", 4);
        
        Set set=map.keySet();//返回Set集合，存放map的键的值
        for(Object o:set){
            System.out.println(o);//输出对象的键
            System.out.println(map.get(o));//输出对象的值，无序
        }
        Iterator iter2=set.iterator();
        while(iter2.hasNext()){//遍历
            System.out.println(map.get(iter2.next()));
        }
        Collection c=map.values();//返回Collection
        Iterator iter3=c.iterator();
        while(iter3.hasNext()){
            System.out.println(iter3.next());
        }
    }
}

Iterator iterator():迭代器，集合的专用遍历方式

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Test1 {
    public static void main(String[] args) {
        // 创建集合对象
        Collection c = new ArrayList();

        // 创建并添加元素
        // String s = "hello";
        // c.add(s);
        c.add("hello");
        c.add("world");
        c.add("java");

        // Iterator iterator():迭代器，集合的专用遍历方式
        Iterator it = c.iterator(); // 实际返回的肯定是子类对象，这里是多态

        // Object obj = it.next();返回下一个元素，然后跳到下一个，最开始因为本身没有所以返回的是第一个
        // System.out.println(obj);
        // System.out.println(it.next());//返回下一个元素之后自身跳到下一个等待调用
        // System.out.println(it.next());
        // System.out.println(it.next());
        // System.out.println(it.next());
        // 最后一个不应该写，所以，我们应该在每次获取前，如果有一个判断就好了
        // 判断是否有下一个元素，有就获取，没有就不搭理它

        // if (it.hasNext()) {
        // System.out.println(it.next());
        // }
        // if (it.hasNext()) {
        // System.out.println(it.next());
        // }
        // if (it.hasNext()) {
        // System.out.println(it.next());
        // }
        // if (it.hasNext()) {
        // System.out.println(it.next());
        // }
        // if (it.hasNext()) {
        // System.out.println(it.next());
        // }

        // 最终版代码
        while (it.hasNext()) {
            // System.out.println(it.next());
            String s = (String) it.next();
            System.out.println(s);//如果这里输出的是it.next()  就会跳着输出下一个
        }
    }
}

for 迭代

for(Iterator it = c.iterator();it.hasNext();){
            
            String s = (String) it.next();
            System.out.println(s);
        }

这种方法的优势在于，循环结束后 Iterator it 就被销毁了，所以比使用while更加节约资源。

迭代器使用问题的探讨：

Iterator iter=list.iterator();//iterator返回的是子类对象，这里是多态
        while(iter.hasNext()){
            System.out.println("学生姓名："+((Student)iter.next()).getName());//通过转型在调用getName方法
        }

以上这种方法可以通过转型选择性的输出对象的信息，但是需要特别注意的是，输出只能调用一次 next 方法，如果多次调用，再次出现next就是下一个对象了。

迭代器的原理

迭代器为什么是一个接口而不是一个类？

如果迭代器是一个类，这样我们就可以创建迭代器的对象，使用该类的方法来事先集合的遍历。但是Java中有不同的集合类，这些类的数据结构也是不同的，所以存储方式和遍历方式也应该是不同的，所以使用将迭代器定义为一个类是不适合的。

无论是哪种集合，都应该具备获取元素的操作，并且最好在辅助与判断功能，这样在获取前先判断更不容易出错，也就是说判断功能和获取功能应该是一个集合所具备的，而每种集合的方式也不太一样，所以我们把这两个功能提取出来并不具体实现，这就是接口。

真正的实现类，在真正具体的子类中，以内部类的方式体现的。

迭代器的源码

public interface Inteator {
    boolean hasNext();
    Object next(); 
}

public interface Iterable {
    Iterator iterator();
}

public interface Collection extends Iterable {
    Iterator iterator();
}

public interface List extends Collection {
    Iterator iterator();
}

public class ArrayList implements List {
    public Iterator iterator() {
        return new Itr();
    }
    
    private class Itr implements Iterator {
        public boolean hasNext() {}
        public Object next(){} 
    }
}


Collection c = new ArrayList();
c.add("hello");
c.add("world");
c.add("java");
Iterator it = c.iterator();     //new Itr();
while(it.hasNext()) {
    String s = (String)it.next();
    System.out.println(s);
}