java学习笔记（6）——Iterator 迭代器

Iterator 接口

java.util.Itertor接口
迭代，是Collection集合元素的通用获取方式
Iterator也是有泛型的！！
先判断集合中有没有元素，有就取出来，再继续判断，再继续取，直至全部取出。

boolean hasNext()  //判断是否有元素

next()
有元素，则取出元素
remove()

获取实现类的方式：
Collection接口中有个方法，iterator()，这个方法返回的就是迭代器的实现类对象。
Iterator也是有泛型的！！迭代器的泛型跟着集合走，集合什么泛型，迭代器什么泛型

1.使用集合中的方法iterator()获取迭代器的实现类对象，使用Iterator接口接收（多态）；
2.使用Iterator接口中的方法hasNext判断是否有下一个元素；
3.使用Iterator接口中的方法next取出集合中的下一个元素。

        Collection<String> coll = new ArrayList<>();

        coll.add("2");
        coll.add("da");
        coll.add("2ue");

        Iterator<String> it = coll.iterator();

        while (it.hasNext()) {
            String s = it.next();

            System.out.println(s);
        }

实现原理：
获取迭代器实现类对象，并把指针指向集合的-1索引

Iterator<String> it = coll.iterator();

next();
除了取出下一个元素，并且将指针向后移动一位。

增强for循环

底层使用的也是迭代器，使用for循环的格式，简化了迭代器的书写
用来遍历集合和数组
格式：
for(集合/数组的数据类型 变量名: 集合名/数组名) {

sout(变量名);

}

        ArrayList<String> s2 = new ArrayList<>();

        s2.add("dsd");
        s2.add("222");
        s2.add("34e");
        for (String s :s2) {
            System.out.println(s);
        }

---

泛型

一种未知的数据类型，不知道使用什么类型的数据就用泛型
是一个变量，可以接收变量

创建集合对象的时候，就会确定泛型的数据类型

创建集合对象，不使用泛型：
好处：

默认类型是Object类型，可以存储任意类型的数据

弊端：

不安全，引发异常（出现多种数据类型，而且不能使用多态，就是不能使用某类特有的方法，需要向下转型，这时候存在不同的数据类型，向下转型时会出现异常）

创建集合对象，使用泛型：
好处：

避免了类型转化的麻烦
把运行期异常（代码运行之后会抛出的异常），提升到了编译期（写的时候就抛出的）

弊端：

泛型是什么类型，就只能存储什么类型的数据

定义泛型类：

public class Person<E> {
    private E name;

    public Person() {
    }
    public Person(E name) {
        this.name = name;
    }
}

定义含有泛型的方法：

泛型定义在方法的修饰符和返回值类型之间
格式：
修饰符 <泛型> 返回值类型 方法名(参数列表（使用泛型）) {

方法体;

}

含有泛型的方法，在调用方法的时候确定泛型的数据类型
传递什么参数，泛型就是什么类型

    public <M> void method(M m) {
        System.out.println(m);
    }

    public static <S> void method1(S s) {
        System.out.println(s);
    }

含有泛型的接口：

格式：

public interface Iterator<E> {
    E next();
}

使用方式1：定义接口的时候就把类型注明

接口:
public interface Person2<String> {
    public abstract void method(String i);
}
实现类：
public class Person implements Person2<String>{

    @Override
    public void method(String s) {
        
    }
}

使用方式2：
接口使用什么泛型，实现类就使用什么泛型
相当于定义一个含有泛型的类

实现类格式：
public class Person<I> implements Person2<I>{

    @Override
    public void method(I i) {
        
    }
}

泛型通配符

<?>
不知道使用什么类型来接收的时候，可以使用 ? 作为通配符
此时只能接收数据，不能往集合中存储数据，遍历未知类型的时候用的上

?:代表任意的数据类型
只能作为方法的参数的使用。

错误！！！定义时候不能用
ArrayList<?> list01 = new ArrayList<>();

    private static void demo01(ArrayList<?> list) {
        Iterator<?> it = list.iterator();

        while(it.hasNext()) {
        
        //it.next()方法，取出的是Object，可以接收任意的数据类型
            Object o = it.next();
            System.out.println(o);
        }
    }

受限泛型

上限限定：
? extends E
代表使用的泛型只能是E类型的子类/本身
?必须是Number的子类或本身

    private static void getElements(Collection<? extends Number> coll) {

    }

下限限定：
? super E
代表使用的泛型只能是E类型的父类/本身
?必须是Number的父类或本身

    private static void getElements2(Collection<? super Number> coll) {

    }