Iterator迭代器及泛型

11.25知识点
1、Collection集合（单列集合最顶层的接口）
1.1 Collection接口定义的是所有单列集合中共性的方法，所有的单列集合都可以使用
1.2 List接口是Collection的子接口，它是一个有序的集合（存储和取出顺序相同）；可以存储重复的元素；有索引，可以使用普通for循环遍历
1.3 Set接口是Collection的子接口，（TreeSet和HashSet无序，LinkedHashSet是一个有序的集合）不允许存储重复的元素；没有索引，不能使用普通的for循环遍历
1.4 常用的集合共性方法
boolean add(E e); 把给定的对象添加到当前集合中
void clear(); 清空集合中所有的元素
boolean remove(E e); 把给定的对象在当前集合中删除
boolean contains(E e); 判断当前集合中是否包含给定的对象
boolean isEmpty(); 判断当前集合是否为空
int size(); 返回集合中元素的个数
Object[] toArray(); 把集合中的元素存储到数组中

2、Iterator接口（迭代器）
java.util.Iterator
Collection集合没有索引相关的方法，不能用普通的方法遍历，所以就要使用Iterator进行迭代输出
注：Iterator迭代器是一个接口，无法直接创建对象使用，需要使用Iterator的实现类对象，获取实现类的方式比较特殊
需要使用Collection接口中的iterator()方法，返回的就是迭代器的实现类对象
例：Collection coll = new ArrayList<>();
2.1 常用方法
2.1.1 boolean hasNext(); // 如果集合中还有元素可以迭代，则返回true
2.2.2 E next(); // 返回迭代的下一个元素
示例代码：

        Collection<String> coll = new ArrayList<>();
        Iterator<String> it = coll.iterator();
        while (true) {
            if (it.hasNext()) {
                System.out.println(it.next());
            } else {
                return;
            }
        }

3、增强for（foreach）
// 底层使用的也是迭代器，使用for循环格式，简化了迭代器的书写
public interface Iterable
实现这个接口允许对象成为 "foreach" 语句的目标。
// 所有单列集合都可以使用增强for
语法：for (集合/数组类型 变量名 : 集合/数组名称) { sout(变量名)}
示例代码：

        Collection<String> coll = new ArrayList<>();
        coll.add(&quot;古力娜扎&quot;);
        coll.add(&quot;玛尔扎哈&quot;);
        for(String i: coll) {
            System.out.println(i);
        }

4、泛型
// 泛型是一种未知的数据类型，不确定使用什么数据类型的时候，就可以使用泛型
// 泛型也可以看成是一个标量，用来接收数据类型
// 泛型是没有继承概念的
E e Element
T t Type
4.1 使用泛型的好处
4.1.1 创建集合对象，不使用泛型
好处：不使用泛型，默认类型为Object类型，可以存储任意类型的数据
弊端：不安全，会引发异常
4.1.2 创建几个对象，使用泛型
好处：
避免了类型转换的麻烦，存储什么类型，取出就是什么类型
把运行期异常，提升到了编译期
弊端：泛型是什么类型，就只能存储什么类型的数据

4.2 定义含有泛型的类
语法：

        public class Test<E> {
            private E name;

            public E getName() {
                return name;
            }

            public void setName(E name) {
                this.name = name;
            }
        }

        public class TestMian {
            public static void main(String[] args) {
                // 不指定泛型则默认Object类型
                Test test = new Test();
                test.setName(1234);
                Object name = test.getName();
                System.out.println(name);
                System.out.println("==========================");
                // 指定泛型，在创建对象的时候确认泛型的类型
                Test<String> test1 = new Test<>();
                test1.setName("123");
                String name1 = test1.getName();
                System.out.println(name1);
            }
        }

4.3 定义含有泛型的方法

	// 调用方法的时候确定泛型的类型，传入什么类型的参数，泛型就是什么类型
    public static <E> void method(E e) {
        System.out.println(e);
    }

4.4 定义含有泛型的接口

public interface MyInterface<E> {
    public abstract void method (E e);
}
// 可以在定义实现类的时候为泛型确定类型，也可以在创建实现类对象的时候为泛型确定类型

4.4 泛型的通配符

<?> // 使用泛型类或者接口时，传递的数据中，泛型类型不确定时可以使用<?>表示，一旦使用后，就只能用Object类中的共性方法，集合中元素自身的方法无法使用 <?> // 表示未知通配符,可以表示任意的数据类型

注：
1、用<?>只能接受数据，不能往该集合中存储数据
2、不能创建对象使用，只能作为方法的参数使用
代码示例：

public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("123");
        list.add("456");
        method(list);
        ArrayList<Integer> list1 = new ArrayList<>();
        list1.add(121313);
        list1.add(13123123);
        method(list1);
    }

    public static void method(ArrayList<?> list) {
        Iterator<?> it = list.iterator();
        while (it.hasNext()) {
            Object next = it.next();
            System.out.println(next);
        }
    }

4.4 泛型的受限
泛型的上限限定：? extends E 代表使用的泛型只能是E类型的子类/本身
泛型的下限限定：? super E 代表使用的泛型只能是E类型的父类/本身
代码示例：

public static void main(String[] args) {
    Collection<Integer> list1 = new ArrayList<Integer>();
    Collection<String> list2 = new ArrayList<String>();
    Collection<Number> list3 = new ArrayList<Number>();
    Collection<Object> list4 = new ArrayList<Object>();
    
    getElement(list1);
    getElement(list2);//报错
    getElement(list3);
    getElement(list4);//报错
  
    getElement2(list1);//报错
    getElement2(list2);//报错
    getElement2(list3);
    getElement2(list4);
}

  	// 泛型的上限：此时的泛型?，必须是Number类型或者Number类型的子类
	public static void getElement1(Collection<? extends Number> coll){}
	// 泛型的下限：此时的泛型?，必须是Number类型或者Number类型的父类
	public static void getElement2(Collection<? super Number> coll){}