Java进阶—Collection集合、Iterator、增强for、泛型

一、Collection集合

1.概述

集合是java中提供的一种容器，可以用来存储多个数据。

java.util.Collection接口：

所有单列集合的【最顶层的接口】，里边定义了所有单列集合共性的方法。

任意的单列集合都可以使用Collection接口中的方法。

2.共性的方法

- public boolean add(E e):把给定的对象添加到当前集合中

- public void clear():清空集合中所有的元素
 
- public boolean remove(E e):把给定的对象在当前集合中删除

- public boolean contains(E e):判断当前集合中是否包含给定对象

- public boolean isEmpty():判断当前集合是否为空
 
- public int size():返回集合中元素的个数

- public Object[] toArray():把集合中的元素，存储到数组中

3.集合和数组的区别

数组的长度是【固定】的，集合的长度是【可变】的。

数组中存储的是【同一类型】的元素，可以存储【基本数据类型】值，数组也可以存储【对象】。

集合存储的【都是对象】。而且对象的【类型可以不一致】。在开发中一般当对象多的时候，使用集合进行存储。

备注：集合可以看成是可变数组；字符串缓冲区可以看成是可变字符串。

二、集合框架

1.分类
集合按照存储结构可以分为两类：

单列集合：java.util.Collection

双列集合：java.util.map

2.Collection集合

Collection集合是【单列集合类的根接口】，有两个重要的子接口：

java.util.List

java.util.Set

备注：Collection接口没有带索引的方法。

【List & Set】：

List接口的特点：
	元素有序（存储和取出元素顺序相同）、元素可重复、有索引，可以使用普通的for循环遍历

List接口的主要实现类：
	java.util.ArrayList：底层是数组实现的，【查询快、增删慢】
	
	java.util.LinkedList：底层是链表实现的，【增删快、查询慢】


Set接口的特点：
	元素无序、元素不可重复，没有索引，不能使用普通的for循环遍历

Set接口的主要实现类：
	java.util.HashSet：底层是哈希表+红黑树实现的，元素无序

	java.util.LinkedHashSet：底层是哈希表+链表实现的，元素有序

3.顶层接口/抽象类中共性的方法，所有的子类都可以用

4.底层不是接口就是抽象类，无法直接创建对象使用，需要使用底层的子类创建对象使用。

三、Iterator接口

1.概念
java.util.Iterator：主要用于遍历集合中的元素。

Collection接口与Map接口主要用于【存储元素】，而Iterator主要用于【迭代访问（即遍历）】Collection中的元素，因此Iterator对象也被成为迭代器。

2.如何获取对应集合的迭代器？

public Iterator iterator():获取集合对应的迭代器，用来遍历集合中的元素的。

迭代的概念：
即Collection集合元素的【通用获取方式】。在取元素之前要先判断集合中有没有元素，如果有，就把这个元素取出来，继续在判断，如果还有就在取出来。一直把集合中的所有元素全部取出，这种取出方式就称为迭代。

3.Iterator接口的常用方法

public E next():返回迭代的【下一个】元素

public boolean hasNext():如果仍有元素可以迭代，则返回true。

public void remove():从迭代器指向的collection中移除迭代器返回的最后一个元素（可选操作）

4.迭代器的使用步骤

1.使用集合中的方法iterator()获取迭代器的实现类对象，使用Iterator接口接收（多态）

2.使用Iterator接口中的方法hasNext()判断还【有没有下一个】元素

3.使用Iterator接口中的方法next()【取出】集合中的【下一个】元素

备注：重复判断和取出的步骤，此即为迭代。

5.注意事项

1.Iterator迭代器，是一个接口，无法直接使用，需要使用Iterator接口的实现类对象。

2.【获取实现类的方式比较特殊】，Collection接口中有一个方法，叫iterator(),这个方法返回的就是迭代器的实现类对象

Iterator<E> iterator():返回在此collection的元素上进行迭代的迭代器。

3.Iterator<E>接口也是有泛型的，迭代器的泛型跟着集合走，集合是什么泛型，迭代器就是什么泛型

4.获取迭代器的实现类对象时，会把【指针(索引)】指向集合的【-1索引】
  Iterator<String> iter = coll.iterator();	//获取迭代器对象
  这也就是为什么是【下一个】元素的由来。

5.Iterator接口中的方法next()方法可以具体细分为两个步骤：
  （1）取出【下一个】元素
  （2）把指针向后移动一位

四、增强for循环

1.概念
增强for循环，也叫做for each循环，是一个高级for循环，【专门用来遍历数组和集合】。

它的内部原理其实是一个【Iterator迭代器】，所以在遍历的过程中，不能对集合中的元素进行增删操作，其实就是用for循环的写法，简化迭代器的写法。

Collection<E> extends Iterable<E>  
Collection接口是所有单列集合的顶层接口，所有的单列集合都可以使用增强for循环。

2.格式

for(元素的数据类型 变量 ： Collection集合/数组/其他容器){
    System.out.println(变量名);
}

3.注意事项
增强for循环必须有被遍历的目标，目标只能是Collection或者是数组，且仅仅作为遍历操作出现。

4.迭代器 & 增强for

1.使用迭代器遍历集合：
    1.通过集合对象获取迭代器对象
    2.使用循环遍历迭代器（常用while循环）
    3.判断迭代器对象中是否还有元素（hasNext）
    4.有元素则获取（next）

2.增强for遍历集合
    for (数据类型 变量名 : 容器对象){
        // 循环体
    }

五、泛型

1.概念
泛型就是一种未知的数据类型，当我们不知道使用什么数据类型的时候，就可以使用泛型。

泛型也可以看成是一个变量，是用来接收数据类型的。

E e  :  Element  元素

T t  : Type  类型

2.实例分析
ArrayList集合在定义的时候，不知道集合中都会存储什么类型的数据，所以类型使用泛型：

E：未知的数据类型
public class ArrayList<E>{
    public boolean add(E e){}
    public E get(int index){}
}

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

ArrayList<String> list = new ArrayList<String>();
会把数据类型作为参数传递，把String赋值给泛型E

3.使用泛型的好处

不使用泛型时：

//创建集合对象，并向其中添加元素
ArrayList list = new ArrayList();
list.add("abc");
list.add(1);

//使用迭代器遍历list集合
Iterator iter = list.iterator();
while (iter.hasNext()){
    // 存入元素的时候是Object类型，所以取出的时候也是Object类型
    Object obj = iter.next();
    System.out.println(obj);
}

//因为Object obj = "abc";是多态写法，不能访问子类的特有方法
//所以如果想使用String类特有的方法，需要向下转型
//但是，会抛出类型转换异常（ClassCastException），不能把Integer类型转换为String类型
//String s = (String) obj;

使用泛型时：

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

好处：
	1.避免了类型转换的麻烦，存储的是什么类型，取出的就是什么类型
    
    2.不使用泛型时，即使代码错误，只会在运行时抛出错误，编译时不会报错。
      使用泛型时，如果代码出错，在编译时就不会通过，就会报错

弊端：
	泛型是什么类型，就只能存储什么类型的数据，不过这个弊端可以忽略。

4.含有泛型的类

定义一个含有泛型的类时，泛型是一个未知的数据类型，当我们不确定是用什么数据类型的时候，可以使用泛型。

泛型可以接收任意的数据类型，可以使用Integer，String，Student…

创建对象的时候，确定泛型的数据类型

5.含有泛型的方法

定义含有泛型的方法：泛型定义在方法的修饰符和返回值类型之间

格式：
    修饰符 <泛型> 返回值类型 方法名(参数列表(使用泛型)){
        方法体；
    }

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

6.含有泛型的接口

第一种使用方式：定义接口的实现类，实现接口，指定接口的泛型

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

// Scanner类实现了Iterator接口，并指定接口的泛型为String，所以重写的next方法泛型默认就是字符串
public final class Scanner implements Iterator<String>{
    public String next(){}
}

第二种使用方式：接口使用什么泛型，实现类就使用什么泛型，类跟着接口走，这就相当于定义了一个含有泛型的类，创建对象的时候确定泛型的类型。

public interface List<E>{
    boolean add(E e);
    E get(int index);
}
//接口使用什么泛型，实现类就使用什么泛型
public class ArrayList<E> implements List<E>{
    public boolean add(E e) {}
    public E get(int index) {}
}

如何测试含有泛型的接口？

一共有两种使用方式：

    1.指定接口的泛型
    
    2.不指定接口的泛型，实现类的泛型跟着接口走，创建对象的时候确定泛型类型

7.泛型通配符

（1）概念
泛型的通配符：

？：代表任意的数据类型

（2）使用方式
只能作为方法的参数来使用，不能再创建对象时使用。
即可以使用泛型的通配符?来接收数据类型

（3）注意事项
泛型是没有继承的：

Collection<Object> list = new ArrayList<String>();	//这种写法是错误的。

（4）受限泛型【了解即可】

之前设置泛型的时候，实际上是可以任意设置的，只要是类就可以设置。但是在JAVA的泛型中可以指定一个泛型的上限和下限。

【泛型的上限】：
    格式：类型名称 <? extends 类> 对象名称
    意义：只能接收该类型及其子类

【泛型的下限】：
    格式：类型名称 <? super 类> 对象名称
    意义：只能接收该类型及其父类

类与类之间的继承关系：

Integer extends Number extends Object

String extends Object