迭代器、泛型和增强For

Iterator

　　hasNext next

Iterator 迭代器

Collection提供了一个遍历集合的通用方式，迭代器(Iterator)。

获取迭代器的方式是使用Collection定义的方法:

不同的集合迭代器的实现不完全相同

Iterator是接口

1. hasNext与next方法

迭代器用于遍历集合的两个主要方法:
boolean hasNext():　　判断集合是否还有元素可以遍历。
E next():　　　　　　　　返回迭代的下一个元素
遍历集合应遵循“先问后取”的方式，也就是说，应当在确定hasNext()方法的返回值为true的情况下再通过next()方法取元素。
由此可以看出，使用迭代器遍历集合是通过boolean值驱动的，所以它更适合使用while循环来遍历。

public class TestIterator {
/*
 * 问取删
 * 遍历集合
 */
    public static void main(String[] args) {
        Collection c = new ArrayList();
        c.add("java");
        c.add("cpp");
        c.add("php");
        c.add("c#");
        c.add("object-c");
        //获取迭代器
        Iterator it = c.iterator();
        //问
        while(it.hasNext()){
            //获取元素  
            String str = (String)it.next();
            System.out.println(str);
            
        }
        System.out.println("while over");
        for(;it.hasNext();){                               for循环也能实现  可以写一个 ，一个都不写 是死循环
            //获取元素  
            String str = (String)it.next();
                //删除包含c的字符串
            if(str.indexOf("c")!=-1){
                it.remove();
            }
            System.out.println(str);
            
        }
        System.out.println("for over");                  这里只遍历一次   iterator 询问 完了 没有了  for在询问也是一样的结果
        
        
    }
}

增强for循环

Java5.0之后推出了一个新的特性，增强for循环,也称为新循环。该循环不通用于传统循环的工作，其只用于遍历集合或数组。
语法:

for(元素类型 e : 集合或数组){
　　循环体
}

新循环并非新的语法，而是在编译过程中，编译器会将新循环转换为迭代器模式。所以新循环本质上是迭代器。

class TestNewfor{
    public static void main(String[] args) {
        Collection c =new ArrayList();
        c.add("java");
        c.add("cpp");
        c.add("php");
        c.add("c#");
        c.add("object-c");
        //顺序的从集合c中取出元素  赋值给o  进入循环
        for(Object X : c ){
            String str = (String)X;
            System.out.println(str);
        }
            //遍历数组
        String[] array ={"a","b","c","d"}; 
        for(String str : array){
            System.out.println(str);
        }
    }
}

泛型机制

泛型在集合汇总的应用

泛型是Java SE 5.0引入的特性，泛型的本质是参数化类型。在类、接口和方法的定义过程中，所操作的数据类型被传入的参数指定。
Java泛型机制广泛的应用在集合框架中。所有的集合类型都带有泛型参数，这样在创建集合时可以指定放入集合中的对象类型。

Java编译器可以据此进行类型检查，这样可以减少代码在运行时出现错误的可能性。
我们来举个例子，比如ArrayList，其在定义时是这样的:

public class ArrayList<E> {
… … … 
public boolean add(E e) {…};
public E get(int index) {…};
}

由此我们可以看出，再声明ArrayList时，类名的右侧有一个<E>。"<>"表示泛型，而其中可以使用数字字母下划线(数字不能的第一个字符)来表示泛型的名字。(通常我们使用一个大写字母来表示，当然这个不是规定。)这时，在类中声明的方法的参数，返回值类型可以被定义为泛型。这样在创建对象时可以将类型作为参数传递，此时，类定义所有的E将被替换成传入的参数。
例如:

/**
 * 在使用一个类的时候，动态的传人一个或多个类型
 * 来指定该类属性，参数，以及返回值的类型
 * @author Administrator
 *
 */
public class TestColl {
    public static void main(String[] args) {
        //泛型 在集合中的使用时用来约束集合元素的类型
        Collection<String> c = new ArrayList<String>();
        
        c.add("a");
        c.add("b");
        c.add("c");
        for(String str : c){
            System.out.println(str);
        }
                /*
         * 迭代器也支持泛型，我们为迭代器指定泛型的类型
         * 应该与他遍历的集合的泛型类型一致
         */
        Iterator<String> it = c.iterator();
        while(it.hasNext()){
            String str = it.next();
            System.out.println(str);
        }
        
    }